from volta.core.core import Core

config = {
    'volta': {
        'enabled': True,
        'source': '/dev/cu.wchusbserial1420',
        'type': 'binary'
    },
    'phone': {
        'enabled': True,
        'source': '01e345da733a4764',
        'type': 'android',
    },
   'sync': {
       'enabled': True,
       'search_interval': 30
    },
    'uploader':{
        'enabled': True,
        'task': 'LOAD-272'
    }
}

core = Core(config)
try:
    core.configure()
    core.start_test()
except KeyboardInterrupt:
    core.end_test()
finally:
    core.post_process()

from volta.providers.boxes.box_binary import VoltaBoxBinary
from volta.core.config.dynamic_options import DYNAMIC_OPTIONS
from netort.validated_config import ValidatedConfig as VoltaConfig
import queue
import time

config_dict = {
    'volta': {
        'source': '/dev/cu.wchusbserial1420',
        'type': 'binary'
    }
}
config = VoltaConfig(config_dict, DYNAMIC_OPTIONS, 'volta.core')
volta_box = VoltaBoxBinary(config) # VoltaBox class
q = queue.Queue()  # queue for results
volta_box.start_test(q)  # start acquiring data
time.sleep(5)  # do something (start autotests, do manual testing ...)
volta_box.end_test()  # stop acquiring data

# you can read pandas.DataFrames from results queue,
# data format: `['uts', 'value']`. Microseconds from test start and electrical currents value.
print(q.get_nowait())

from volta.providers.phones.android import AndroidPhone
from volta.core.config.dynamic_options import DYNAMIC_OPTIONS
from netort.validated_config import ValidatedConfig as VoltaConfig
import queue
import time
import logging

config_dict = {
    'phone': {
        'source': '01e345da733a4764',
        'type': 'android',
        'test_apps': [
            'http://hostname.tld/path/to/first/apk1.apk',
            'http://hostname.tld/path/to/second/apk2.apk',
        ],
        'test_class': 'ru.yandex.test.highload.Tests',
        'test_package': 'ru.yandex.mobile.test',
        'test_runner': 'android.support.test.runner.AndroidJUnitRunner'
    }
}
config = VoltaConfig(config_dict, DYNAMIC_OPTIONS, 'volta.core')

phone = AndroidPhone(config)  # create Phone class
q = queue.Queue()  # create python queue for results
phone.prepare()  # prepare phone for test - clean logs, install test apps and install volta's `lightning` app for synchronization
phone.start(q)  # start acquiring log messages
phone.run_test()  # run test app, specified in config
time.sleep(5)  # do something ...
phone.end()  # stop acquiring log messages

# you can read pandas.DataFrames from results queue,
# data format: `['sys_uts', 'message']`. Microseconds from first event in phone log and message.
print(q.get_nowait())

from volta.providers.phones.iphone import iPhone
from netort.validated_config import ValidatedConfig as VoltaConfig
from volta.core.config.dynamic_options import DYNAMIC_OPTIONS

import queue

config_dict = {
    'phone': {
        'source': '0x6382910F98C26',
        'type': 'iphone',
    }
}
config = VoltaConfig(config_dict, DYNAMIC_OPTIONS, 'volta.core')
phone = iPhone(config)  # create Phone class
q = queue.Queue()  # create python queue for results
phone.prepare()  # prepare for test
phone.start(q)  # start phone log data acquiring
phone.end()  # stop phone log data acquiring

from volta.providers.phones.android import AndroidPhone
from volta.mappers.events.router import EventsRouter
from volta.listeners.report.report import FileListener
from volta.core.config.dynamic_options import DYNAMIC_OPTIONS
from netort.validated_config import ValidatedConfig as VoltaConfig


import queue
import time
import uuid

test_id = uuid.uuid4()  # some test id

config_dict = {
    'phone': {
        'source': '01e345da733a4764',
        'type': 'android',
    },
}
config = VoltaConfig(config_dict, DYNAMIC_OPTIONS, 'volta.core')
phone = AndroidPhone(config)  # create Phone instance
phone_q = queue.Queue()  # create python queue for results
phone.start(phone_q)  # start acquiring phone log messages

event_types = ['event', 'sync', 'fragment', 'metric', 'unknown'] # define event types
event_listeners = {key:[] for key in event_types} # create dict w/ empty list for each event type

event_fnames = {
    key:"{data}_{id}.data".format(
        data=key,
        id=test_id
    ) for key in event_types
}  # file name for each event type

# setup FileListener for each event type (at this sample we write each event type to its own file)
for type, fname in event_fnames.items():
    listener_config = {'fname': fname}
    f = FileListener(listener_config)
    event_listeners[type].append(f)

events_router = EventsRouter(phone_q, event_listeners)
events_router.start()  # start phone log messages processing and routing

time.sleep(10)
phone.end()  # stop acquiring phone log messages
time.sleep(5)
events_router.close()  # stop phone log messages processing and rouring

# in the end you will have files w/ events for each event type in current working directory

from volta.core.config.dynamic_options import DYNAMIC_OPTIONS
from volta.providers.boxes.box500hz import VoltaBox500Hz
from volta.providers.phones.android import AndroidPhone
from volta.mappers.events.router import EventsRouter
from volta.listeners.sync.sync import SyncFinder
from netort.data_processing import Tee
from netort.validated_config import ValidatedConfig as VoltaConfig

import queue
import time

# setup Volta and start
config_dict = {
    'volta': {
        'source': '/dev/cu.wchusbserial1420',
        'type': '500hz'
    },
    'phone': {
        'source': '01e345da733a4764',
        'type': 'android'
    },
    'sync': {
        'search_interval': 30
    },
}
config = VoltaConfig(config_dict, DYNAMIC_OPTIONS, 'volta.core')
volta_box = VoltaBox500Hz(config)  # create VoltaBox class
volta_q = queue.Queue()  # create python queue for volta results
volta_listeners = []  # create electrical current listeners list

# setup Phone and start
phone = AndroidPhone(config)  # create Phone class
phone_q = queue.Queue()  # create python queue for results

# setup EventsRouter
event_types = ['event', 'sync', 'fragment', 'metric', 'unknown']  # define event types
event_listeners = {key:[] for key in event_types}  # create dict w/ empty list for each event type
events_router = EventsRouter(phone_q, event_listeners)

# at the moment we have electrical currents queue and phone queue
sync_finder = SyncFinder(config)  # create SyncFinder class

# subscribe our SyncFinder to electrical current and sync events
volta_listeners.append(sync_finder)
event_listeners['sync'].append(sync_finder)

# now process electrical currents to listeners
# Tee drains the queue and send data to listeners
process_volta_data = Tee(
    volta_q,
    volta_listeners,
    'currents'
)

volta_box.start_test(volta_q)  # start volta_box data acquiring
process_volta_data.start()  # start volta_box data processing
phone.start(phone_q)  # start acquiring phone log messages
events_router.start()  # start phone logs processing and routing

# do some work... or maybe phone.run_test()
time.sleep(15)

volta_box.end_test()  # stop volta_box data acquiring
process_volta_data.close()  # stop volta_box data processing
phone.end()  # stop acquiring phone log messages
events_router.close()  # stop phone logs processing and routing

offsets = sync_finder.find_sync_points()
print(offsets)
# output format:
# sys_uts_offset is the phone's system uts to volta's uts offset
# log_uts_offset is the phone's logs custom events nanotime to volta's uts offset
# {'sys_uts_offset': -1005000, 'sync_sample': 0, 'log_uts_offset': 0}

from volta.providers.boxes.box500hz import VoltaBox500Hz
from volta.listeners.report.report import FileListener
from volta.core.config.dynamic_options import DYNAMIC_OPTIONS
from netort.data_processing import Tee
from netort.validated_config import ValidatedConfig as VoltaConfig
import queue
import time
import logging

config_dict = {
    'volta': {
        'source': '/dev/cu.wchusbserial1420',
        'type': '500hz'
    }
}
config = VoltaConfig(config_dict, DYNAMIC_OPTIONS, 'volta.core')
volta_box = VoltaBox500Hz(config)  # VoltaBox class
volta_q = queue.Queue()  # queue for results
volta_listeners = []  # empty list for listeners

# create FileListeners and subscribe it to volta
report_config = {'fname': 'current_output_filename'}
file_listener = FileListener(report_config)
volta_listeners.append(file_listener)

volta_data_process = Tee(volta_q, volta_listeners, 'currents')  # start volta data processing

volta_box.start_test(volta_q)  # start test and pass results queue
volta_data_process.start()
time.sleep(15) # do something (start autotests, do manual testing ...). I passed 5 seconds sleep as a placeholder.
volta_box.end_test()  # end test execution
volta_data_process.close()

from volta.providers.boxes.box500hz import VoltaBox500Hz
from volta.listeners.uploader.uploader import DataUploader
from volta.core.config.dynamic_options import DYNAMIC_OPTIONS
from netort.data_processing import Tee
from netort.validated_config import ValidatedConfig as VoltaConfig
import queue
import time
import logging

config_dict = {
    'volta': {
        'source': '/dev/cu.wchusbserial1420',
        'type': '500hz'
    },
    'uploader': {
        'task': 'LOAD-272'
    }
}
config = VoltaConfig(config_dict, DYNAMIC_OPTIONS, 'volta.core')
volta_box = VoltaBox500Hz(config)  # VoltaBox class
volta_q = queue.Queue()  # queue for results
volta_listeners = []  # emptry list for listeners

# create DataUploader and subscribe it to volta_box
uploader = DataUploader(config)
volta_listeners.append(uploader)

volta_data_process = Tee(volta_q, volta_listeners, 'currents')  # start volta data processing

volta_box.start_test(volta_q)  # start test and pass results queue
volta_data_process.start()
time.sleep(15) # do something (start autotests, do manual testing ...). I passed 5 seconds sleep as a placeholder.
volta_box.end_test()  # end test execution
volta_data_process.close()