def run(self, loop: AbstractEventLoop) -> None:
"""Runs the asynchronous task.
Args:
loop: The event loop on which to schedule the task.
"""
self.logger.info("%s task running", self.purpose)
loop.create_task(self.task(), name=self.purpose)
def create_async_task(self, loop: AbstractEventLoop) -> TaskAwaitable:
"""Return asyncio Task for task run in asyncio loop."""
self._agent.runtime.set_loop(loop)
if not isinstance(self._agent.runtime, AsyncRuntime): # pragma: nocover
raise ValueError(
"Agent runtime is not async compatible. Please use runtime_mode=async"
)
return loop.create_task(self._agent.runtime.start_and_wait_completed())
def create_async_task(self, loop: AbstractEventLoop) -> TaskAwaitable:
"""
Return asyncio Task for task run in asyncio loop.
:param loop: abstract event loop
:return: task to run runtime
"""
self._agent.runtime.set_loop(loop)
if not isinstance(self._agent.runtime, AsyncRuntime):
raise ValueError(
"Agent runtime is not async compatible. Please use runtime_mode=async"
)
return loop.create_task(self._agent.runtime.run_runtime())
def __init__(self, event_loop: AbstractEventLoop, sock: socket,
address: Any, on_msg: Callable[[str, str], None],
on_dc: Callable[[str], None]) -> None:
self.id = uuid4().hex
self.sock = sock
self.event_loop = event_loop
self.address = address
self.on_msg = on_msg
self.on_dc = on_dc
welcome_msg = dedent("""
===============================================
Hello!
You are now connected to the chat server.
Your messages will be broadcast to other users.
===============================================
""")
event_loop.create_task(self.listen_for_msgs())
event_loop.create_task(self.send_msg(welcome_msg))
logger.info(f"[{self.id}] initialized.")
def test_locallogstreamer(capsys, event_loop: AbstractEventLoop) -> None:
logger = StreamingLogger()
logger.reset("xxx", "yyy")
streamer = log_streamer.LocalLogStreamer(
[ToyHandler()],
logger,
)
async def _toy_logging(logger: StreamingLogger,
streamer: log_streamer.LocalLogStreamer) -> None:
await asyncio.sleep(0.1)
# logging by logger
logger.log("test\n")
# log will be sent into streamer, and handler, then printted out
await asyncio.sleep(0.3)
streamer.handle_exit(SIGINT, None)
event_loop.create_task(streamer.entry_point())
event_loop.run_until_complete(_toy_logging(logger, streamer))
event_loop.stop()
captured = capsys.readouterr()
assert captured.out == "toy-test\n"
def register_device(device, loop: AbstractEventLoop):
for value in registered_devices.values():
if device == value['device']:
return value['task']
input = find_input(device)
if input is None:
return None
input.grab()
caps = input.capabilities()
# EV_SYN is automatically added to uinput devices
del caps[ecodes.EV_SYN]
remappings = device['remappings']
extended = set(caps[ecodes.EV_KEY])
modifier_groups = []
if 'modifier_groups' in device:
modifier_groups = device['modifier_groups']
def flatmap(lst):
return [l2 for l1 in lst for l2 in l1]
for remapping in flatmap(remappings.values()):
if 'code' in remapping:
extended.update([remapping['code']])
for group in modifier_groups:
for remapping in flatmap(modifier_groups[group].values()):
if 'code' in remapping:
extended.update([remapping['code']])
caps[ecodes.EV_KEY] = list(extended)
output = UInput(caps, name=device['output_name'])
print('Registered: %s, %s, %s' % (input.name, input.path, input.phys),
flush=True)
task = loop.create_task(handle_events(input, output, remappings,
modifier_groups),
name=input.name)
registered_devices[input.path] = {
'task': task,
'device': device,
'input': input,
}
return task
async def handle_depth_stream(
symbol: str,
session: ClientSession,
dispatcher: DiffDepthStreamDispatcher,
database: Database,
logger: Logger,
loop: AbstractEventLoop,
asset_type: AssetType,
):
next_full_fetch = time()
logger.log_msg(f"Connecting to {asset_type.value + symbol} stream",
LoggingLevel.INFO, symbol)
prev_final_update_id = None
while True:
async with session.ws_connect(depth_stream_url(symbol,
asset_type)) as ws:
async for msg in ws:
if msg.type == aiohttp.WSMsgType.TEXT:
try:
data_raw = DiffDepthStreamMsg(**msg.json())
except ValidationError:
print(msg.data)
break
s = data_raw.E / 1000.0
timestamp = datetime.utcfromtimestamp(s)
if asset_type == AssetType.SPOT:
first_update_id = data_raw.U
final_update_id = data_raw.u
else:
first_update_id = data_raw.pu + 1
final_update_id = data_raw.u
bids_quantity = [pairs[1] for pairs in data_raw.b]
bids_price = [pairs[0] for pairs in data_raw.b]
asks_quantity = [pairs[1] for pairs in data_raw.a]
asks_price = [pairs[0] for pairs in data_raw.a]
symbol = data_raw.s
symbol_full = asset_type.value + symbol
if next_full_fetch < time():
logger.log_msg(
f"Fetching {symbol_full} full market depth",
LoggingLevel.INFO,
symbol_full,
)
next_full_fetch += CONFIG.full_fetch_interval
loop.create_task(
get_full_depth(symbol, session, database,
asset_type))
if (prev_final_update_id
and prev_final_update_id + 1 != first_update_id):
logger.log_msg(
f"LOB dropped for {symbol_full}, refetching full market depth",
LoggingLevel.INFO,
symbol_full,
)
dispatcher.insert(
timestamp,
first_update_id,
final_update_id,
bids_quantity,
bids_price,
asks_quantity,
asks_price,
symbol_full,
)
if msg.type == aiohttp.WSMsgType.CLOSE:
break
logger.log_msg(
f"Connection closed for {symbol_full} stream, retrying.",
LoggingLevel.INFO,
symbol,
)
next_full_fetch = time()
def create_shutdown_task(loop: AbstractEventLoop):
return loop.create_task(shutdown(loop))