def main():
if os.name == 'nt':
loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
else:
loop = asyncio.get_event_loop()
loop.run_until_complete(start(
'sleep 2; wc', input=[b'foo bar baz\n'*300 for i in range(100)]))
loop.close()
def setup_eventloop(self):
"""
Sets up a new eventloop as the current one according to the OS.
"""
if os.name == 'nt':
self.eventloop = asyncio.ProactorEventLoop()
if sys.version_info <= (3, 0):
# FIXME: There appears to be a bug in the 2.7 version of trollius, wherein the selector retrieves an
# object of value 0 and attempts to look for it in the weakref set, which raises an exception.
# This hack sidesteps this issue, but does not solve it. If a proper fix is found, apply it!
self.eventloop._selector._stopped_serving = set()
else:
self.eventloop = asyncio.new_event_loop()
asyncio.set_event_loop(self.eventloop)
def test_asyncserial_timeout_error():
'''
Verify serial device AsyncSerial instance is still tied up after closing.
In Windows, it turns out that the serial port is tied up by an AsyncSerial
instance until the corresponding event loop is closed. This test tests
that this is true.
'''
ports = serial.tools.list_ports.comports()
if not ports:
raise RuntimeError('No comports available.')
kwargs = {'port': ports[0].device}
@asyncio.coroutine
def _open_asyncserial():
with asyncserial.AsyncSerial(**kwargs) as async_device:
yield asyncio.From(asyncio.sleep(5))
raise asyncio.Return(None)
def _open_serial(retries=1):
for i in range(retries):
try:
with serial.Serial(**kwargs):
pass
break
except serial.SerialException as exception:
pass
else:
raise exception
_open_serial()
try:
loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
loop.run_until_complete(asyncio.wait_for(_open_asyncserial(),
timeout=2))
except asyncio.TimeoutError:
pass
try:
_open_serial()
except serial.SerialException:
raises(serial.SerialException)(_open_serial)()
def test_asyncserial_timeout_workaround():
'''
Test closing event loop to free up device AsyncSerial instance.
'''
ports = serial.tools.list_ports.comports()
if not ports:
raise RuntimeError('No comports available.')
kwargs = {'port': ports[0].device}
@asyncio.coroutine
def _open_asyncserial():
with asyncserial.AsyncSerial(**kwargs) as async_device:
yield asyncio.From(asyncio.sleep(5))
raise asyncio.Return(None)
def _open_serial(retries=1):
for i in range(retries):
try:
with serial.Serial(**kwargs):
pass
break
except serial.SerialException as exception:
pass
else:
raise exception
_open_serial()
try:
loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
loop.run_until_complete(asyncio.wait_for(_open_asyncserial(),
timeout=2))
except asyncio.TimeoutError:
pass
finally:
# Close event loop.
loop.close()
try:
_open_serial()
except serial.SerialException:
_open_serial()
def run(self, command, *args, **kwargs):
self_ = self
class SubprocessProtocol(asyncio.SubprocessProtocol):
def pipe_data_received(self, fd, data):
self_._write(fd, re.sub(r'(\r?\n)+', r'\1', data))
def connection_lost(self, exc):
loop.stop() # end loop.run_forever()
if os.name == 'nt':
# For subprocess' pipes on Windows
loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
else:
loop = asyncio.get_event_loop()
try:
if kwargs.pop('shell', False):
proc = loop.subprocess_shell(SubprocessProtocol, command)
else:
proc = loop.subprocess_exec(SubprocessProtocol, *command)
def _refresh_gui():
refresh_gui()
loop.call_soon(_refresh_gui)
loop.call_soon(_refresh_gui)
transport, protocol = loop.run_until_complete(proc)
loop.run_forever()
except Exception as exception:
self._write(2, str(exception))
else:
return transport.get_returncode()
finally:
loop.close()
def setUp(self):
self.loop = asyncio.ProactorEventLoop()
self.set_event_loop(self.loop)
sys_name = platform.system()
if sys_name == "Linux":
import fcntl
import clib as c
from tunlib import *
from linux import TapLinuxInterface
TDInt = TapLinuxInterface
elif sys_name == "Windows" or sys_name == "cli":
from winlib import *
from win import TapWinInterface
TDInt = TapWinInterface
loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
else:
raise NotImplementedError("tap driver only available on linux and windows")
from time import sleep
usleep = lambda x: sleep(x / 1000000.0)
from ctypes import cast, pointer, POINTER, sizeof
from dev_fns import _device_setup, _enable_rx, _enable_tx
from link import _link_detect
from interrupt import _handle_interrupt
def async_msleep(self, t):
def platform_setup(driver):
driver.loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(driver.loop)
driver.kbd_h = GetStdHandle(STD_INPUT_HANDLE)
def run_test(way_points,
start_electrode,
output_dir,
video_dir=None,
overwrite=False,
svg_source=None,
launch=False,
resolution=(1280, 720),
device_id=0,
multi_sensing=False,
voltage=115):
'''
Parameters
----------
way_points : list[int]
Contiguous list of waypoints, where test is routed as the shortest path
between each consecutive pair of waypoints.
start_electrode : int
Waypoint to treat as starting point.
If not the first waypoint in ``way_points``, the test route will "wrap
around" until the ``start_electrode`` is reached again.
output_dir : str
Directory to write output files to.
May include ``'%(uuid)s'`` as placeholder for chip UUID, e.g.,
``~/my_output_dir/%(uuid)s-results``.
video_dir : str, optional
Directory within which to search for videos corresponding to the start
time of the test.
If a related video is found, offer to move/rename the video with the
same name and location as the output results file.
overwrite : bool, optional
If ``True``, overwrite output files. Otherwise, ask before
overwriting.
svg_source : str or file-like, optional
A file path, URI, or file-like object containing DropBot chip SVG
source.
launch : bool, optional
Launch output path after creation (default: `False`).
resolution : tuple[int, int], optional
Target video resolution (may be ignored if not supported by device).
device_id : int, optional
OpenCV video capture device identifier (default=0).
multi_sensing : bool, optional
If `True`, run multi-sensing test. Otherwise, run single-drop test
(default: `False`).
.. versionchanged:: 0.2
Add ``video_dir`` keyword argument.
.. versionchanged:: 0.3
Add ``output_dir`` argument; and ``overwrite`` and ``svg_source``
keyword arguments.
.. versionchanged:: 0.4
Write each test result a self-contained HTML file in the specified
output directory.
.. versionchanged:: 1.6.0
Add ``launch`` keyword argument.
.. versionchanged:: 0.7.0
Add ``resolution`` and ``device_id`` keyword arguments.
.. versionchanged:: 0.8.0
Add ``multi_sensing`` keyword argument.
.. versionchanged:: 0.9.0
Update to support new return type from `connect()`, use ``proxy``
attribute of ``monitor_task``, and ``channels_graph`` attribute of
``proxy``.
.. versionchanged:: 0.10.0
Explicitly execute a shorts detection test at the start of a chip test.
.. versionchanged:: 0.10.0
Add chip info to logged ``test-start`` message.
.. versionchanged:: 0.11.0
Add ``voltage`` keyword argument (actuation RMS voltage).
.. versionchanged:: 0.11.1
Remove shorted channels from adjacent channels graph.
'''
output_dir = ph.path(output_dir)
if video_dir is not None:
video_dir = ph.path(video_dir)
ready = threading.Event()
closed = threading.Event()
loop = asyncio.ProactorEventLoop()
asyncio.set_event_loop(loop)
signals = blinker.Namespace()
signals.signal('closed').connect(lambda sender: closed.set(), weak=False)
logging.info('Wait for connection to DropBot...')
monitor_task = connect(svg_source=svg_source)
proxy = monitor_task.proxy
G = proxy.channels_graph
proxy.voltage = voltage
def update_video(video, uuid):
response = question('Attempt to set UUID in title of video file, '
'`%s`?' % video,
title='Update video?')
if response == QMessageBox.StandardButton.Yes:
try:
f = mutagen.File(video)
if ('\xa9nam' not in f.tags) or ('UUID'
not in f.tags['\xa9nam']):
f.tags['\xa9nam'] = \
'DMF chip QC - UUID: %s' % uuid
f.save()
logging.info('wrote UUID to video title: `%s`', video)
except Exception:
logging.warning('Error setting video title.', exc_info=True)
# Substitute UUID into output directory path as necessary.
path_subs_dict = {'uuid': uuid}
path_subs_dict.update(_date_subs_dict())
output_dir_ = ph.path(output_dir %
path_subs_dict).expand().realpath()
output_dir_.makedirs_p()
output_path = output_dir_.joinpath('%s.mp4' % uuid)
if not output_path.exists() or overwrite or \
(question('Output `%s` exists. Overwrite?' % output_path,
title='Overwrite?') ==
QMessageBox.StandardButton.Yes):
if output_path.exists():
output_path.remove()
ph.path(video).move(output_path)
logging.info('moved video to : `%s`', output_path)
def on_chip_detected(sender, **kwargs):
@ft.wraps(on_chip_detected)
def wrapped(sender, **kwargs):
signals.signal('chip-detected').disconnect(on_chip_detected)
uuid = kwargs['decoded_objects'][0].data
ready.uuid = uuid
ready.set()
# Wait for chip to be detected.
response = None
while response != QMessageBox.StandardButton.Yes:
response = question('Chip detected: `%s`.\n\nReady to load '
'electrode %s?' % (uuid, start_electrode),
title='Chip detected')
proxy.stop_switching_matrix()
proxy.turn_off_all_channels()
@asyncio.coroutine
def _run():
dropbot_events = []
def log_event(message):
# Add UTC timestamp to each event.
message['utc_time'] = dt.datetime.utcnow().isoformat()
dropbot_events.append(message)
# Log route events in memory.
def log_route_event(event, message):
# Tag kwargs with route event name.
message['event'] = event
# Add chip, DropBot, and version info to `test-start`
# message.
if event == 'test-start':
message['uuid'] = uuid
message['dropbot.__version__'] = db.__version__
message['dropbot_chip_qc.__version__'] = __version__
message['dropbot'] = {
'system_info': db.self_test.system_info(proxy),
'i2c_scan': db.self_test.test_i2c(proxy)
}
message['dmf_chip.__version'] = dc.__version__
message['chip-info'] = copy.deepcopy(proxy.chip_info)
log_event(message)
# Log results of shorts detection tests.
proxy.signals.signal('shorts-detected').connect(log_event)
if MULTI_SENSING_ENABLED and multi_sensing:
# Log multi-sensing capacitance events (in memory).
proxy.signals.signal('sensitive-capacitances')\
.connect(log_event)
# Use multi-sensing test implementation.
_run_test = _multi_run_test
else:
# Use single-drop test implementation.
_run_test = _single_run_test
loggers = {
e: ft.partial(
lambda event, sender, **kwargs: log_route_event(
event, kwargs), e)
for e in ('electrode-success', 'electrode-fail',
'electrode-skip', 'test-start', 'test-complete')
}
for event, logger in loggers.items():
signals.signal(event).connect(logger)
# Explicitly execute a shorts detection test.
for shorted_channel in proxy.detect_shorts():
if shorted_channel in G:
print('remove shorted channel: %s' % shorted_channel,
file=sys.stderr)
G.remove_node(shorted_channel)
try:
start = time.time()
yield asyncio.From(
_run_test(signals,
proxy,
G,
way_points,
start=start_electrode))
if video_dir:
# A video directory was provided. Look for a video
# corresponding to the same timeline as the test.
# Only consider videos that were created within 1
# minute of the start of the test.
videos = sorted(
(p for p in video_dir.expand().files('*.mp4')
if abs(p.ctime - start) < 60),
key=lambda x: -x.ctime)
if videos:
loop.call_soon_threadsafe(update_video, videos[-1],
uuid)
except nx.NetworkXNoPath as exception:
logging.error('QC test failed: `%s`',
exception,
exc_info=True)
def write_results():
# Substitute UUID into output directory path as necessary.
path_subs_dict = {'uuid': uuid}
path_subs_dict.update(_date_subs_dict())
output_dir_ = ph.path(output_dir %
path_subs_dict).expand().realpath()
output_dir_.makedirs_p()
# Write logged events to file.
output_path = \
output_dir_.joinpath('Chip test report - %s.html' %
uuid)
if not output_path.exists() or overwrite or \
(question('Output `%s` exists. Overwrite?' %
output_path, title='Overwrite?') ==
QMessageBox.StandardButton.Yes):
render_summary(dropbot_events,
output_path,
svg_source=svg_source)
logging.info('wrote events log to: `%s`', output_path)
if launch:
# Launch result using default system viewer.
output_path.launch()
loop.call_soon_threadsafe(write_results)
signals.signal('chip-detected').connect(on_chip_detected)
qc_task = cancellable(_run)
thread = threading.Thread(target=qc_task)
thread.daemon = True
thread.start()
loop.call_soon_threadsafe(ft.partial(wrapped, sender, **kwargs))
signals.signal('chip-detected').connect(on_chip_detected)
thread = threading.Thread(target=chip_video_process,
args=(signals, resolution[0], resolution[1],
device_id))
thread.start()
# Launch window to view chip video.
loop.run_until_complete(show_chip(signals))
# Close background thread.
signals.signal('exit-request').send('main')
closed.wait()
