def _attempt_connect(**kwargs): ignore = kwargs.pop('ignore', []) try: # Attempt to connect to automatically selected port. dropbot = db.SerialProxy(port=port, ignore=ignore, **kwargs) raise asyncio.Return(dropbot) except db.proxy.NoPower as exception: # No 12V power supply detected on DropBot. _L().debug('No 12V power supply detected.') responses = signals.signal('no-power').send('keep_alive') for t in asyncio.as_completed( [loop.create_task(r[1]) for r in responses]): response = yield asyncio.From(t) if response == 'ignore': ignore.append(db.proxy.NoPower) break else: raise exception except bnr.proxy.DeviceVersionMismatch as exception: # Firmware version does not match driver version. _L().debug( 'Driver version (`%s`) does not match firmware ' 'version (`%s`)', db.__version__, exception.device_version) responses = signals.signal('version-mismatch')\ .send('keep_alive', driver_version=db.__version__, firmware_version=exception.device_version) update = False for t in asyncio.as_completed( [loop.create_task(r[1]) for r in responses]): response = yield asyncio.From(t) if response == 'ignore': ignore.append(bnr.proxy.DeviceVersionMismatch) break elif response == 'update': update = True break else: raise if update: # Flash firmware and retry connection. _L().info('Flash firmware and retry connection.') yield asyncio.From(co_flash_firmware()) dropbot = yield asyncio.From( _attempt_connect(ignore=ignore, **kwargs)) raise asyncio.Return(dropbot)
def set_waveform(key, value): exception = None result = signals.signal('set-%s' % key).send(value) if result: try: receivers, co_callbacks = zip(*result) if receivers: results = yield asyncio.From(asyncio.gather(*co_callbacks)) except asyncio.CancelledError: raise except Exception as exception: pass else: if receivers: raise asyncio.Return(zip(receivers, results)) if exception is not None: message = ('Error setting **%s**: `%s`' % (key, exception)) else: message = ('No waveform generators available to set **%s**.' % key) yield asyncio.From( _warning(signals.signal('warning'), message, title='Warning: failed to set %s' % key, key='waveform-%s' % key))
def list_controllers(self, timeout): @asyncio.coroutine def on_response_received(packet, future): self.logger.debug("List of controllers received with status={}".format( packet.status)) self.remove_callback(packet.packet_uuid) if packet.status_code == StatusCode.Success: controllers = packet.get(name='controllers', format_function=lambda raw_ctrls: [ Controller.from_flatbuffers(raw_ctrl) for raw_ctrl in raw_ctrls ]) future.set_result(controllers) else: future.set_exception( BaBLEException(packet, "Failed to list controllers")) future = asyncio.Future() request_packet = Packet.build(GetControllersList) self.register_callback(request_packet.packet_uuid, callback=on_response_received, params={'future': future}) self.send_packet(request_packet) self.logger.debug("Waiting for list of controllers...") try: controllers = yield From(asyncio.wait_for(future, timeout=timeout)) raise asyncio.Return(controllers) except asyncio.TimeoutError: self.remove_callback(request_packet.packet_uuid) raise RuntimeError("List controllers timed out")
def schema_input(schema, message='**Please fill in the following fields:**', description=None): ''' Asynchronous GTK input dialog based on JSON schema. Parameters ---------- schema : dict JSON schema. message : str, optional Message presented in dialog. description : str, optional Title of input dialog. Returns ------- dict or None Mapping from field name to entered value if ``OK`` button was pressed. Otherwise, ``None``. ''' # Wrap dialog function call in partial since `gtk_threadsafe` does # not support passing keyword arguments. dialog_func = ft.partial(schema_dialog, schema, title=description, type=gtk.MESSAGE_OTHER, message_format=markdown2pango(message), buttons=gtk.BUTTONS_OK_CANCEL) # Queue dialog to be launched in GTK thread and wait for response. response = yield asyncio.From(sync(gtk_threadsafe)(dialog_func)()) if response is None: raise RuntimeError('Cancelled in response to message `%s`.' % message) raise asyncio.Return(response)
def read_frame(signals): ''' :py:mod:`trollius` `asyncio` wrapper to return a single frame produced by a ``frame-ready`` event signalled by :func:`dropbot_chip_qc.video.chip_video_process()`. Parameters ---------- signals : blinker.Namespace DMF chip webcam monitor signals (see :func:`dropbot_chip_qc.video.chip_video_process()`). ''' loop = asyncio.get_event_loop() frame_ready = asyncio.Event() response = {} def on_frame_ready(sender, **message): response.update(message) loop.call_soon_threadsafe(frame_ready.set) signals.signal('frame-ready').connect(on_frame_ready) yield asyncio.From(frame_ready.wait()) raise asyncio.Return(response)
def transfer_windows(signals, channel_plan, completed_transfers, co_transfer, n=2): def on_transfer_complete(sender, **message): transfer_i = message['completed_transfers'][-1] print('\r%-100s' % ('completed transfer `%s` to `%s`' % (transfer_i['channels'][:-1], transfer_i['channels'][1:])), end='') signals.signal('transfer-complete').connect(on_transfer_complete) channel_plan_i = list(channel_plan) while len(channel_plan_i) > 1: try: channel_plan_i, completed_transfers = yield asyncio\ .From(_next_transfer(channel_plan=channel_plan_i, completed_transfers=completed_transfers, co_transfer=co_transfer, n=n)) except Exception as exception: raise TransferFailed(channel_plan_i, completed_transfers, exception) else: signals.signal('transfer-complete')\ .send(caller_name(0), channel_plan=channel_plan_i, completed_transfers=completed_transfers) channel_plan_i = [] result = dict(channel_plan=channel_plan_i, completed_transfers=completed_transfers) signals.signal('test-complete').send(caller_name(0), **result) raise asyncio.Return(result)
def call(ES_URL, queries): results = [] results_append = results.append futures = _do_calls(ES_URL, queries) for future in futures: result = yield trollius.From(future) results_append(result) raise trollius.Return(results)
def _next_transfer(channel_plan, completed_transfers, co_transfer, n=2): transfer_channels = channel_plan[:n] result = yield asyncio.From(co_transfer(transfer_channels)) raise asyncio.Return( channel_plan[1:], completed_transfers + [{ 'channels': transfer_channels, 'result': result }])
def actuate_channels(self, channels, allow_disabled=True): ''' Parameters ---------- channels : list List of channel numbers to actuate. allow_disabled : bool, optional If ``False``, verify actuated channels match specified channels _exactly_. Otherwise, ensure that all actuated channels belong to the specified set of channels, _even if_ not _all_ specified channels are actuated. This supports attempting to actuate channels that are disabled. Returns ------- list List of actuated channels. If :data:`allow_disabled` is ``True``, the returned list of channels may differ from the specified list of channels. Raises ------ RuntimeError If list actuated channels does not match the requested channels (missing disabled channels are ignored if ``allowed_disabled`` is `True`). ''' loop = asyncio.get_event_loop() channels_updated = asyncio.Event() def _on_channels_updated(message): channels_updated.actuated = message.get('actuated') loop.call_soon_threadsafe(channels_updated.set) # Enable `channels-updated` DropBot signal. self.enable_event(db.proxy.EVENT_CHANNELS_UPDATED) # Request to be notified when the set of actuated channels changes. signal = self.signals.signal('channels-updated') signal.connect(_on_channels_updated) # Request actuation of the specified channels. self.set_state_of_channels(pd.Series(1, index=channels), append=False) yield asyncio.From(channels_updated.wait()) if not allow_disabled and (set(channels_updated.actuated) != set(channels)): raise RuntimeError('Actuated channels `%s` do not match ' 'expected channels `%s`' % (channels_updated.actuated, channels)) elif set(channels_updated.actuated) - set(channels): # Disabled channels are allowed. raise RuntimeError('Actuated channels `%s` are not included in' ' expected channels `%s`' % (channels_updated.actuated, channels)) raise asyncio.Return(channels_updated.actuated)
def probe_characteristics(self, controller_id, connection_handle, start_handle, end_handle, on_characteristics_probed, timeout): if isinstance(on_characteristics_probed, (tuple, list)): on_characteristics_probed_cb = on_characteristics_probed[0] on_characteristics_probed_params = on_characteristics_probed[1:] else: on_characteristics_probed_cb = on_characteristics_probed on_characteristics_probed_params = [] @asyncio.coroutine def on_response_received(packet, future): self.logger.debug( "Probe characteristics response received with status={}".format( packet.status)) self.remove_callback(packet.packet_uuid) if packet.status_code == StatusCode.Success: characteristics = packet.get_dict([ 'controller_id', 'connection_handle', ('characteristics', lambda chars: [Characteristic.from_flatbuffers(char) for char in chars]) ]) on_characteristics_probed_cb(True, characteristics, None, *on_characteristics_probed_params) future.set_result(characteristics) else: error = BaBLEException(packet, "Failed to probe characteristics", connection_handle=connection_handle) on_characteristics_probed_cb(False, None, error, *on_characteristics_probed_params) future.set_exception(error) future = asyncio.Future() request_packet = Packet.build(ProbeCharacteristics, controller_id=controller_id, connection_handle=connection_handle, start_handle=start_handle, end_handle=end_handle) self.register_callback(request_packet.packet_uuid, callback=on_response_received, params={'future': future}) self.send_packet(request_packet) self.logger.debug("Waiting for characteristics...") try: characteristics = yield From(asyncio.wait_for(future, timeout=timeout)) raise asyncio.Return(characteristics) except asyncio.TimeoutError: self.remove_callback(request_packet.packet_uuid) raise RuntimeError("Probe characteristics timed out")
def read(self, controller_id, connection_handle, attribute_handle, on_read, timeout): if isinstance(on_read, (tuple, list)): on_read_cb = on_read[0] on_read_params = on_read[1:] else: on_read_cb = on_read on_read_params = [] @asyncio.coroutine def on_response_received(packet, future): self.logger.debug("Read response received with status={}".format( packet.status)) self.remove_callback(packet.packet_uuid) if packet.status_code == StatusCode.Success: data = packet.get_dict([ 'controller_id', 'connection_handle', 'attribute_handle', ('value', bytes) ]) on_read_cb(True, data, None, *on_read_params) future.set_result(data) else: error = BaBLEException(packet, "Failed to read value", connection_handle=connection_handle, attribute_handle=attribute_handle) on_read_cb(False, None, error, *on_read_params) future.set_exception(error) future = asyncio.Future() request_packet = Packet.build(ReadCentral, controller_id=controller_id, connection_handle=connection_handle, attribute_handle=attribute_handle) self.register_callback(request_packet.packet_uuid, callback=on_response_received, params={'future': future}) self.send_packet(request_packet) self.logger.debug("Reading...") try: result = yield From(asyncio.wait_for(future, timeout=timeout)) raise asyncio.Return(result) except asyncio.TimeoutError: self.remove_callback(request_packet.packet_uuid) on_read_cb(False, None, "Read timed out", *on_read_params) raise RuntimeError("Read timed out")
def transfer_liquid(aproxy, channels, **kwargs): ''' Transfer liquid from tail n-1 channels to head n-1 channels. xxxx... -> ...xxxx where ``x`` denotes liquid and ``.`` denotes an empty electrode. This is accomplished through two separate actuations:: 1. Actuate all but the **last** channel in ``channels``. 2. Actuate all but the **first** channel in ``channels``. Actuation **(1)** is applied until a steady-state capacitance is reached. At this point, the measured capacitance is recorded as a target threshold. Actuation **(2)** is then applied until the target threshold capacitance from actuation **(1)** is reached. ''' messages_ = [] try: tail_channels_i = list(channels[:-1]) route_i = list( it.chain(*(c if isinstance(c, collections.Sequence) else [c] for c in tail_channels_i))) print('\r%-50s' % ('Wait for steady state: %s' % list(route_i)), end='') messages = yield asyncio\ .From(actuate(aproxy, route_i, ft.partial(test_steady_state_, **kwargs))) messages_.append({'channels': tuple(route_i), 'messages': messages}) target_capacitance_i = ((float(len(channels) - 1) / len(channels)) * messages[-1]['new_value']) head_channels_i = list(channels[1:]) print('\r%-50s' % ('Wait for target capacitance of: %sF' % si.si_format(target_capacitance_i)), end='') route_i = list( it.chain(*(c if isinstance(c, collections.Sequence) else [c] for c in head_channels_i))) def test_threshold(messages): df = pd.DataFrame(messages[-5:]) return df.new_value.median() >= target_capacitance_i messages = yield asyncio\ .From(actuate(aproxy, route_i, test_threshold)) messages_.append({'channels': tuple(route_i), 'messages': messages}) except (asyncio.CancelledError, asyncio.TimeoutError): raise TransferTimeout(channels) raise asyncio.Return(messages_)
def execute(plugin_kwargs, signals): ''' XXX Coroutine XXX Parameters ---------- plugin_kwargs : dict Plugin settings as JSON serializable dictionary. signals : blinker.Namespace Signals namespace. ''' if NAME not in plugin_kwargs: raise asyncio.Return([]) else: kwargs = plugin_kwargs[NAME] # Wait for plugins to connect to signals as necessary. event = asyncio.Event() signals.signal('signals-connected').connect(lambda *args: event.set(), weak=False) yield asyncio.From(event.wait()) voltage = kwargs['Voltage (V)'] frequency = kwargs['Frequency (Hz)'] duration_s = kwargs['Duration (s)'] static_states = kwargs.get('electrode_states', pd.Series()) dynamic = kwargs.get('dynamic', True) result = yield asyncio.From( execute_actuations(signals, static_states, voltage, frequency, duration_s, dynamic=dynamic)) logger = _L() # use logger with function context logger.info('%d/%d actuations completed', len(result), len(result)) logger.debug('completed actuations: `%s`', result) raise asyncio.Return(result)
def load(proxy, channels, threshold=50e-12, load_duration=.25, detach_duration=2.): '''Load reservoir to specified threshold capacitance. Steps:: 1. Load: actuate first electrode until threshold capacitance is met. 2. Detach: turn off first electrode and actuate the remaining electrodes until threshold capacitance is met. Parameters ---------- channels : list List of channel numbers to actuate. threshold : float, optional Minimum median capacitance in Farads (from most recent ``N`` samples) before considering load complete (default: 50 pF). load_duration : float, optional Seconds before first electrode capacitance is considered stable (default: 0.25). detach_duration : float, optional Seconds before detaching electrodes capacitance is considered stable (default: 0.5). Returns ------- list See `wait_on_capacitance()` for return type. ''' # Load starting reservoir. logging.debug('Wait for channel `%s` to be loaded', channels[:1]) yield asyncio.From( actuate( proxy, channels[:-1], ft.partial(test_steady_state, min_duration=load_duration, threshold=1.1 * threshold))) detach_channels = channels[1:] logging.debug( 'Wait for liquid to detach from edge electrode `%s` to ' '`%s`...', channels[:1], detach_channels) messages = yield asyncio\ .From(actuate(proxy, detach_channels, ft.partial(test_steady_state, min_duration=detach_duration, threshold=threshold))) raise asyncio.Return(messages)
def actuate(proxy, channels, callback): '''Actuate channels and wait for callback to return `True`. Parameters ---------- channels : list List of channel numbers to actuate. callback Callback function accepting a list of ``capacitance-updated`` messages as only argument. ''' # Actuate channels. yield asyncio.From(actuate_channels(proxy, channels)) # Wait for callback. result = yield asyncio.From(wait_on_capacitance(proxy, callback)) raise asyncio.Return(result)
def execute_test(*args, **kwargs): yield asyncio.From(set_capacitance_update_interval()) try: result = yield asyncio\ .From(qc.ui.plan.transfer_windows(*args, **kwargs)) except qc.ui.plan.TransferFailed as exception: # Save intermediate result. result = dict( channel_plan=exception.channel_plan, completed_transfers=exception.completed_transfers) signals.signal('test-interrupt').send(caller_name(0), **result) self.completed_results.append(result) yield asyncio.From( aproxy.set_state_of_channels(pd.Series(), append=False)) # result = dict(channel_plan=channel_plan_i, # completed_transfers=completed_transfers_i) raise asyncio.Return(result)
def cancel_connection(self, controller_id, on_connection_cancelled, timeout): if isinstance(on_connection_cancelled, (tuple, list)): on_connection_cancelled_cb = on_connection_cancelled[0] on_connection_cancelled_params = on_connection_cancelled[1:] else: on_connection_cancelled_cb = on_connection_cancelled on_connection_cancelled_params = [] @asyncio.coroutine def on_response_received(packet, future): self.logger.debug( "Cancel connection response received with status={}".format( packet.status)) self.remove_callback(packet.packet_uuid) if packet.status_code == StatusCode.Success: on_connection_cancelled_cb(True, None, None, *on_connection_cancelled_params) future.set_result(True) else: error = BaBLEException(packet, "Failed to cancel connection") on_connection_cancelled_cb(False, None, error, *on_connection_cancelled_params) future.set_exception(error) future = asyncio.Future() request_packet = Packet.build(CancelConnection, controller_id=controller_id) self.register_callback(request_packet.packet_uuid, callback=on_response_received, params={'future': future}) self.send_packet(request_packet) self.logger.debug("Waiting for connection to cancel...") try: result = yield From(asyncio.wait_for(future, timeout=timeout)) raise asyncio.Return(result) except asyncio.TimeoutError: self.remove_callback(request_packet.packet_uuid) on_connection_cancelled_cb(False, None, "Cancel connection timed out", *on_connection_cancelled_params) raise RuntimeError("Cancel connection timed out")
def set_gatt_table(self, controller_id, services, characteristics, on_set, timeout): if isinstance(on_set, (tuple, list)): on_set_cb = on_set[0] on_set_params = on_set[1:] else: on_set_cb = on_set on_set_params = [] @asyncio.coroutine def on_response_received(packet, future): self.logger.debug("GATT table set with status={}".format( packet.status)) self.remove_callback(packet.packet_uuid) if packet.status_code == StatusCode.Success: data = packet.get_dict(['controller_id']) on_set_cb(True, data, None, *on_set_params) future.set_result(data) else: error = BaBLEException(packet, "Failed to set GATT table") on_set_cb(False, None, error, *on_set_params) future.set_exception(error) future = asyncio.Future() request_packet = Packet.build(SetGATTTable, controller_id=controller_id, services=services, characteristics=characteristics) self.register_callback(request_packet.packet_uuid, callback=on_response_received, params={'future': future}) self.send_packet(request_packet) self.logger.debug("Waiting for setting GATT table response...") try: result = yield From(asyncio.wait_for(future, timeout=timeout)) raise asyncio.Return(result) except asyncio.TimeoutError: self.remove_callback(request_packet.packet_uuid) raise RuntimeError("Set GATT table timed out")
def wait_for_result(client, verb, prefix, name, *args, **kwargs): ''' Example ------- >>> client = Client(client_id='DropBot MQTT bridge') >>> ... >>> # bind MQTT client to DropBot monitor blinker signals namespace... >>> ... >>> prefix = '/dropbot/' + str(dropbot.uuid) >>> call = ft.partial(wait_for_result, client, 'call', prefix) >>> property = ft.partial(wait_for_result, client, 'property', prefix) >>> ... >>> loop = asyncio.get_event_loop() >>> loop.run_until_complete(property('voltage', 80)) ''' loop = asyncio.get_event_loop() result = asyncio.Event() def on_received(client, userdata, message): try: payload = message.payload or 'null' result.data = jt.loads(payload) except Exception: result.data = json.loads(payload) try: module_name = '.'.join(result.data['__instance_type__'][:-1]) class_name = result.data['__instance_type__'][-1] module = __import__(module_name) cls = getattr(module, class_name) result.data = cls(**result.data['attributes']) except Exception: pass loop.call_soon_threadsafe(result.set) client.message_callback_add('%s/result/%s' % (prefix, name), on_received) try: payload = jt.dumps({'args': args, 'kwargs': kwargs}) client.publish('%s/%s/%s' % (prefix, verb, name), payload=payload, qos=1) yield asyncio.From(result.wait()) finally: client.message_callback_remove(sub='%s/result/%s' % (prefix, name)) raise asyncio.Return(result.data)
def stop_scan(self, controller_id, on_scan_stopped, timeout): if isinstance(on_scan_stopped, (tuple, list)): on_scan_stopped_cb = on_scan_stopped[0] on_scan_stopped_params = on_scan_stopped[1:] else: on_scan_stopped_cb = on_scan_stopped on_scan_stopped_params = [] @asyncio.coroutine def on_response_received(packet, future): self.logger.debug("Stop scan response received with status={}".format( packet.status)) self.remove_callback(packet.packet_uuid) if packet.status_code == StatusCode.Success: self.remove_callback( PacketUuid(payload_type=Payload.DeviceFound, controller_id=controller_id)) on_scan_stopped_cb(True, packet.get_dict(['controller_id']), None, *on_scan_stopped_params) future.set_result(True) else: error = BaBLEException(packet, "Failed to stop scan") on_scan_stopped_cb(False, None, error, *on_scan_stopped_params) future.set_exception(error) future = asyncio.Future() request_packet = Packet.build(StopScan, controller_id=controller_id) self.register_callback(request_packet.packet_uuid, callback=on_response_received, params={'future': future}) self.send_packet(request_packet) self.logger.debug("Waiting for scan to stop...") try: result = yield From(asyncio.wait_for(future, timeout=timeout)) raise asyncio.Return(result) except asyncio.TimeoutError: self.remove_callback(request_packet.packet_uuid) on_scan_stopped_cb(False, None, "Stop scan timed out", *on_scan_stopped_params) raise RuntimeError("Stop scan timed out")
def get_ws_token(self, qlist): loop = trollius.get_event_loop() async_req = loop.run_in_executor( None, functools.partial(self.sina.session.get, URL_WSKT_TOKEN, params=PARAM_WSKT_TOKEN(ip=self.ip, qlist=qlist, hq=self.hq), headers=HEADERS_WSKT_TOKEN(), timeout=5)) req = yield trollius.From(async_req) # self.logger.info(req.text) response = re.findall(r'(\{.*\})', req.text)[0] response = json.loads( response.replace(',', ',"').replace('{', '{"').replace(':', '":')) # gc.collect() raise trollius.Return(response)
def on_no_power(*args, **kwargs): while True: response = raw_input('No 12V power supply detected. ' '[I]gnore/[s]kip: ') if not response: # Default response is `ignore` and try to connect anyway. response = 'ignore' for action in ('ignore', 'skip'): if action.startswith(response.lower()): response = action break else: print('Invalid response: `%s`' % response) response = None if response is not None: break raise asyncio.Return(response)
def notify(self, controller_id, connection_handle, attribute_handle, value, timeout): # TODO: use characteristic instead of attribute_handle @asyncio.coroutine def on_ack_received(packet, future): self.logger.debug( "EmitNotification ack received with status={}".format( packet.status)) self.remove_callback(packet.packet_uuid) if packet.status_code == StatusCode.Success: future.set_result(True) else: error = BaBLEException(packet, "Failed to send EmitNotification packet", connection_handle=connection_handle, attribute_handle=attribute_handle) future.set_exception(error) future = asyncio.Future() request_packet = Packet.build(EmitNotification, controller_id=controller_id, connection_handle=connection_handle, attribute_handle=attribute_handle, value=bytes(value)) self.register_callback(request_packet.packet_uuid, callback=on_ack_received, params={'future': future}) self.send_packet(request_packet) try: result = yield From(asyncio.wait_for(future, timeout=timeout)) self.logger.debug("Notification sent") raise asyncio.Return(result) except asyncio.TimeoutError: self.remove_callback(request_packet.packet_uuid) raise RuntimeError("Notification timed out")
def wait_on_capacitance(proxy, callback): '''Return once callback returns `True`. Parameters ---------- callback Callback function accepting a list of ``capacitance-updated`` messages as only argument. Returns ------- list List of DropBot ``capacitance-updated`` messages containing the following keys:: - ``event``: ``"capacitance-updated"`` - ``new_value``: capacitance value in Farads - ``time_us``: DropBot microsecond 32-bit counter - ``n_samples``: number of samples used for RMS measurement - ``V_a``: measured actuation voltage during capacitance reading ''' move_done = asyncio.Event() loop = asyncio.get_event_loop() messages = [] def _on_capacitance(message): # message.keys == ['event', 'new_value', 'time_us', 'n_samples', 'V_a'] # Added by `co_target_capacitance()`: 'actuation_uuid1', 'actuated_channels' try: messages.append(message) if callback(messages): loop.call_soon_threadsafe(move_done.set) except Exception: logging.debug('capacitance event error.', exc_info=True) return proxy.signals.signal('capacitance-updated').connect(_on_capacitance) yield asyncio.From(move_done.wait()) raise asyncio.Return(messages)
def _dynamic_states(): # Merge received actuation states from requests with # explicit states stored by this plugin. requests = [] responses = signals.signal('get-electrode-states-request').send() for receiver_i, co_callback_i in responses: request_i = yield asyncio.From(co_callback_i) if request_i is not None: requests.append(request_i) logger = _L() if logger.getEffectiveLevel() >= logging.DEBUG: message = ('receiver: %s, actuation_request=%s' % (receiver_i, request_i)) map(logger.debug, message.splitlines()) if requests: combined_states = pd.concat([r[r > 0] for r in requests]) else: combined_states = pd.Series() raise asyncio.Return(combined_states)
def write_without_response(self, controller_id, connection_handle, attribute_handle, value, timeout): @asyncio.coroutine def on_ack_received(packet, future): self.logger.debug( "WriteWithoutResponse ack received with status={}".format( packet.status)) self.remove_callback(packet.packet_uuid) if packet.status_code == StatusCode.Success: future.set_result(True) else: error = BaBLEException( packet, "Failed to send WriteWithoutResponse packet", connection_handle=connection_handle, attribute_handle=attribute_handle) future.set_exception(error) future = asyncio.Future() request_packet = Packet.build(WriteWithoutResponseCentral, controller_id=controller_id, connection_handle=connection_handle, attribute_handle=attribute_handle, value=bytes(value)) self.register_callback(request_packet.packet_uuid, callback=on_ack_received, params={'future': future}) self.send_packet(request_packet) try: result = yield From(asyncio.wait_for(future, timeout=timeout)) self.logger.debug("Write without response command sent") raise asyncio.Return(result) except asyncio.TimeoutError: self.remove_callback(request_packet.packet_uuid) raise RuntimeError("WriteWithoutResponse timed out")
def _warning(signal, message, **kwargs): ''' XXX Coroutine XXX Send warning signal and gather response from receivers. If no receivers are available or any receiver raises an exception, raise the specified warning message as a `RuntimeError`. Raises ------ RuntimeError If no receivers are available or any receiver raises an exception. ''' responses = signal.send(message, **kwargs) try: receivers, co_callbacks = zip(*responses) results = yield asyncio.From(asyncio.gather(*co_callbacks)) except Exception: raise RuntimeError(message) else: raise asyncio.Return(zip(receivers, results))
def on_version_mismatch(*args, **kwargs): _L().info('args=`%s`, kwargs=`%s`', args, kwargs) message = ('Driver version `%(driver_version)s` does not match ' 'firmware `%(firmware_version)s` version.' % kwargs) while True: response = raw_input(message + ' [I]gnore/[u]pdate/[s]kip: ') if not response: # Default response is `ignore` and try to connect anyway. response = 'ignore' for action in ('ignore', 'update', 'skip'): if action.startswith(response.lower()): response = action break else: print('Invalid response: `%s`' % response) response = None if response is not None: break if response == 'skip': raise IOError(message) raise asyncio.Return(response)
def execute_step(plugin_kwargs): ''' .. versionadded:: 2.32 XXX Coroutine XXX Execute a single protocol step. Parameters ---------- plugin_kwargs : dict Plugin keyword arguments, indexed by plugin name. Returns ------- list Return values from plugin ``on_step_run()`` coroutines. ''' # Take snapshot of arguments for current step. plugin_kwargs = copy.deepcopy(plugin_kwargs) signals = blinker.Namespace() @asyncio.coroutine def notify_signals_connected(): yield asyncio.From(asyncio.sleep(0)) signals.signal('signals-connected').send(None) loop = asyncio.get_event_loop() # Get list of coroutine futures by emitting `on_step_run()`. plugin_step_tasks = emit_signal("on_step_run", args=[plugin_kwargs, signals]) future = asyncio.wait(plugin_step_tasks.values()) loop.create_task(notify_signals_connected()) result = yield asyncio.From(future) raise asyncio.Return(result)
def get_quote_coroutine(self, symbols, dataframe): loop = trollius.get_event_loop() if isinstance(symbols, list) or isinstance(symbols, set) or isinstance( symbols, tuple): symbolList = list(symbols) elif isinstance(symbols, str): symbolList = symbols.split(',') symbols = util.symbols_to_string(symbols) url = URL_QUOTATION(symbols) retry = True while retry: try: async_req = loop.run_in_executor( None, functools.partial(self.session.get, URL_QUOTATION(symbols), timeout=0.1)) quote = yield trollius.From(async_req) retry = False except: pass quote = quote.text quote = re.findall(r'\"(.*)\"', quote) for i in range(0, len(quote)): quote[i] = quote[i].split(',') if dataframe: quote = DataFrame(quote, columns=SINA_QUOTE_COLUMNS) quote["symbol"] = symbolList quote["time"] = datetime.strptime( quote.iloc[0]["date"] + " " + quote.iloc[0]["time"], '%Y-%m-%d %H:%M:%S') else: quote = [[x] + y for x, y in zip(symbolList, quote)] raise trollius.Return(quote)