def __init__(self, loop: AbstractEventLoop):
super(OKEXAPI, self).__init__()
self.loop = loop
self.rest_api = OKEXRESTTradeAPI(loop)
self.ws_api = OKEXWSTradeAPI(loop)
self.ws_api.set_msg_handler(self)
loop.create_task(self.create_session())
def register(loop: asyncio.AbstractEventLoop, app: web.Application) -> None:
gateway_sessions = {} # type: Dict[str, GatewaySession]
app['gateway_sessions'] = gateway_sessions
app.router.add_route('OPTIONS', '/gateway/gateway.dll', handle_http_gateway_options)
app.router.add_post('/gateway/gateway.dll', handle_http_gateway)
loop.create_task(_clean_gateway_sessions(gateway_sessions))
async def test_paginate_timeout(
self,
context: MockContext,
fetcher: ListPageSource[int],
event_loop: asyncio.AbstractEventLoop,
advance_time: ClockAdvancer,
) -> None:
p = InteractivePager.create(cast(Any, context), fetcher)
assert p.paginating
event_loop.create_task(p.paginate())
await advance_time(70)
assert p.paginating
await advance_time(125)
assert not p.paginating
page = await fetcher.get_page(1)
assert p.embed.description == '\n'.join([
page['entry_text'],
'',
'Confused? React with \N{INFORMATION SOURCE} for more info.',
])
assert not hasattr(p.embed.footer.text, 'text')
context.channel.send.assert_awaited_once_with(embed=p.embed)
assert isinstance(p.message, MockMessage)
assert p.message.add_reaction.await_count == 7
context.message.clear_reactions.assert_not_awaited()
p.message.clear_reactions.assert_awaited_once_with()
p.message.remove_reaction.assert_not_awaited()
assert p.match is None
async def connect(
self,
loop: asyncio.AbstractEventLoop = asyncio.get_event_loop()) -> None:
while True:
try:
conn = await websockets.connect(
self.url_socket, extra_headers={"Token": self.token})
self.socket = ackWebsockets.Socket(conn)
await self.on_connect()
async def on_disconnect():
await self.on_disconnect()
await self.reconnect()
self.socket.onDisconnect(on_disconnect)
async def on_error(ex: Exception):
await self.on_error(ex)
await self.reconnect()
self.socket.onError(on_error)
self.socket.on("init", self.on_init)
self.socket.on("stop", self.on_stop)
self.socket.on_sync("instruction", self.on_instruction)
loop.create_task(self.socket.run())
break
except Exception as e: # todo: catch concrete exceptions
await self.on_error(e)
self.socket = None
await asyncio.sleep(10)
def start(self, loop: asyncio.AbstractEventLoop):
if hasattr(self, 'started') and self.started:
# prevent a backend callback from starting more than 1 writer and creating more than 1 queue
return
self.queue = Queue()
loop.create_task(self.writer())
self.started = True
def start(loop: asyncio.AbstractEventLoop,
framerate: int = DEFAULT_FRAMERATE) -> asyncio.Future:
return asyncio.gather(
loop.create_task(_ui_refresh(loop, framerate)),
loop.create_task(_process_inputs(loop)),
loop=loop,
)
def setup(dp: Dispatcher, loop: AbstractEventLoop = None, *args, **kwargs):
logging.info('Initialize default module')
loop.create_task(
forever_run(
function=check_connection,
interval=CONNECTION_CHECKER_INTERVAL,
))
dp.register_message_handler(cmd_start, Command('start'), state='*')
dp.register_message_handler(cmd_help, Command('help'), state='*')
dp.register_message_handler(cmd_cancel, Command('cancel'), state='*')
dp.register_message_handler(
cmd_start,
lambda message:
[user for user in message.new_chat_members if bot_id == user.id],
content_types=ContentType.NEW_CHAT_MEMBERS,
)
dp.register_message_handler(
cmd_start,
content_types=ContentType.GROUP_CHAT_CREATED,
)
dp.register_callback_query_handler(
answer_callback_empty_button_handler,
lambda query: query.data == 'None',
)
async def test_paginate_next_checked(
self,
context: MockContext,
fetcher: ListPageSource[int],
event_loop: asyncio.AbstractEventLoop,
advance_time: ClockAdvancer,
) -> None:
p = InteractivePager.create(cast(Any, context), fetcher)
event_loop.create_task(p.paginate())
await advance_time(0)
reaction = MockReaction.create(
'\N{BLACK RIGHT-POINTING DOUBLE TRIANGLE WITH VERTICAL BAR}',
p.message.id)
await context.bot._dispatch_wait_for('reaction_add', reaction,
context.author)
await advance_time(5)
reaction = MockReaction.create('\N{BLACK RIGHT-POINTING TRIANGLE}',
p.message.id)
await context.bot._dispatch_wait_for('reaction_add', reaction,
context.author)
await advance_time(5)
assert p.paginating
assert p.current_page == 3
assert isinstance(p.message, MockMessage)
assert p.message.edit.await_count == 1
await advance_time(125)
async def run_app(
loop: asyncio.AbstractEventLoop,
payload: List[dict],
entity: str,
mock_url: str,
) -> None:
asyncio.set_event_loop(loop)
with aioresponses() as mocked:
body = ndjson.dumps(payload)
mocked.get(mock_url, status=200, body=body)
test_app = init_app(
loop=loop,
settings=settings,
command_line_args=argparse.Namespace(verbose=False))
if entity == "patients":
task = loop.create_task(test_app.resolve_patients())
elif entity == "encounters":
task = loop.create_task(test_app.resolve_encounters())
elif entity == "procedures":
task = loop.create_task(test_app.resolve_procedures())
elif entity == "observations":
task = loop.create_task(test_app.resolve_observations())
else:
raise ValueError("unknown entity")
await asyncio.sleep(SLEEP_PERIOD)
task.cancel()
await asyncio.gather(task, return_exceptions=True)
def test_catch_broken_queue_error(event_loop: AbstractEventLoop) -> None:
"""test for deleting log queue when read queue is awaiting streaming data from log queue"""
logstreamer = ToyLogStreamer([log_streamer.QueueHandler()])
read_streamer = LocalReadStreamer(logstreamer)
async def flow(read_streamer: LocalReadStreamer):
id = "xxx"
key = "key-something"
# add pipe between log streamer and application read streamer
await read_streamer.add_client(id, key)
assert read_streamer._id_to_logqueue.get(id)
assert read_streamer._key_to_readqueue.get(key)
with pytest.raises(ValueError):
# keep awaitting to read streamer get log until timeout
await read_streamer.get(key)
# successfully raise error and break all running asynchronous process
async def post_flow(logstreamer):
await asyncio.sleep(0.3)
# force delete log queue
logstreamer.delete("xxx")
await asyncio.sleep(0.3)
event_loop.create_task(flow(read_streamer))
event_loop.run_until_complete(post_flow(logstreamer))
event_loop.close()
def _schedule_stop(
self,
exception: Optional[Exception] = None,
loop: asyncio.AbstractEventLoop = None,
):
loop = self.event_loop if loop is None else loop
loop.create_task(self.stop(exception=exception))
async def setup_liveness(self, loop: asyncio.AbstractEventLoop):
async def advance_liveness_time(liveness):
while True:
await liveness.advance_time(round(time.time()))
await asyncio.sleep(1)
await self.liveness_recorder.start()
loop.create_task(advance_liveness_time(self.liveness_recorder))
def start(
loop: asyncio.AbstractEventLoop, framerate: int = DEFAULT_FRAMERATE
) -> asyncio.Future:
return asyncio.gather(
loop.create_task(_ui_refresh(loop, framerate)),
loop.create_task(_process_inputs(loop)),
loop=loop,
)
async def start_client(loop: asyncio.AbstractEventLoop = None):
if loop:
client = CivDiscordNotifyBotClient(loop=loop)
else:
loop = asyncio.get_event_loop()
token = os.getenv("CIV6_NOTIFY_DISCORD_TOKEN")
print("Connecting...")
loop.create_task(client.start(token))
def create_tasks(
loop: asyncio.AbstractEventLoop,
lifecycle: Optional[Callable] = None,
registry: Optional[registries.BaseRegistry] = None,
standalone: bool = False,
priority: int = 0,
peering_name: str = peering.PEERING_DEFAULT_NAME,
namespace: Optional[str] = None,
):
"""
Create all the tasks needed to run the operator, but do not spawn/start them.
The tasks are properly inter-connected depending on the runtime specification.
They can be injected into any event loop as needed.
"""
# The freezer and the registry are scoped to this whole task-set, to sync them all.
lifecycle = lifecycle if lifecycle is not None else lifecycles.get_default_lifecycle(
)
registry = registry if registry is not None else registries.get_default_registry(
)
freeze = asyncio.Event()
tasks = []
# Monitor the peers, unless explicitly disabled.
ourselves: Optional[peering.Peer] = peering.Peer.detect(
id=peering.detect_own_id(),
priority=priority,
standalone=standalone,
namespace=namespace,
name=peering_name,
)
if ourselves:
tasks.extend([
loop.create_task(peering.peers_keepalive(ourselves=ourselves)),
loop.create_task(
watcher(namespace=namespace,
resource=ourselves.resource,
handler=functools.partial(
peering.peers_handler,
ourselves=ourselves,
freeze=freeze))), # freeze is set/cleared
])
# Resource event handling, only once for every known resource (de-duplicated).
for resource in registry.resources:
tasks.extend([
loop.create_task(
watcher(namespace=namespace,
resource=resource,
handler=functools.partial(
handling.custom_object_handler,
lifecycle=lifecycle,
registry=registry,
resource=resource,
freeze=freeze))), # freeze is only checked
])
return tasks
def _connect_bots(loop: _asyncio.AbstractEventLoop):
"""
Helper function used to create tasks and run the bots in an async loop.
"""
dof_bot_run_task = loop.create_task(_connect(dof_bot, _DOF_BOT_TOKEN))
testing_bot_run_task = loop.create_task(
_connect(testing_bot, _TESTING_BOT_TOKEN))
loop.run_until_complete(
_asyncio.gather(dof_bot_run_task, testing_bot_run_task))
def init(bot: commands.Bot, loop: asyncio.AbstractEventLoop) -> None:
async def check_uploads():
while True:
for channel in staticconfig.channel_list:
await check_and_notify(bot, channel)
await asyncio.sleep(staticconfig.delay_refresh)
loop.create_task(check_uploads())
async def _do_loop(self, loop: AbstractEventLoop):
while loop.is_running():
try:
sent_from, message = self.in_queue.get(timeout=0.1)
loop.create_task(
self._handle_message(message, sent_from, self._state))
except Empty:
pass
await asyncio.sleep(0)
def _run_next_serial_plotting(self, loop: asyncio.AbstractEventLoop, queue: str = "default"):
next_plot_id = None
for item in self.plots_queue:
if item["queue"] == queue and item["state"] is PlotState.SUBMITTED and item["parallel"] is False:
next_plot_id = item["id"]
if next_plot_id is not None:
loop.create_task(self._start_plotting(next_plot_id, loop, queue))
def connection_lost_handler(self, loop: AbstractEventLoop,
context: Dict[str, Any]) -> None:
exception = context.get('exception')
if isinstance(exception, exceptions.ConnectionLostError):
logging.warning('Connection lost -- trying to reconnect')
close_task = loop.create_task(self.stop())
wait_for(close_task, None)
loop.create_task(self.start())
else:
loop.default_exception_handler(context)
def pass_command_to_loop(command: str, client: MPDClient, loop: asyncio.AbstractEventLoop):
"""
Utility function that calls specified command on MPD Client
in specified EventLoop
:param command: command to be called
:param client: an instance of MPDClient
:param loop: target EventLoop
:return: None
"""
loop.create_task(client.send_command(command))
def connect(
self,
websocket: WebSocket,
filter_id: Optional[UUID] = None,
loop: asyncio.AbstractEventLoop = asyncio.get_event_loop(),
) -> UUID:
connection_id = super().connect(websocket, filter_id=filter_id, loop=loop)
if filter_id is not None and filter_id in self._last_events:
loop.create_task(websocket.send_json(self._last_events[filter_id]))
return connection_id
def start_listening(self, loop: asyncio.AbstractEventLoop = None):
"""
Attaches the server to an existing event loop, which presumably will later have
loop.run_forever() called with other things attached to it.
:param asyncio.AbstractEventLoop loop: the loop to attach
"""
loop = loop or asyncio.get_event_loop()
loop.create_task(self.__listen_for_connection())
self.loop = loop
async def spawn_app(
app: ASGIFramework,
loop: asyncio.AbstractEventLoop,
config: Config,
scope: dict,
send: Callable[[dict], Awaitable[None]],
) -> Callable[[dict], Awaitable[None]]:
app_queue: asyncio.Queue = asyncio.Queue(config.max_app_queue_size)
loop.create_task(_handle(app, config, scope, app_queue.get, send))
return app_queue.put
def ScheduleTelemetryRequest(loop: asyncio.AbstractEventLoop,
Queue: asyncio.Queue, Module, delay: float):
print('Scheduling new telemtry request on event loop')
Msg = {
'InterfaceType': Module['InterfaceType'],
'MessageType': 'ModuleCommand',
'Address': Module['Address'],
'FunctionCode': config.REQ_TEL
}
loop.create_task(ScheduleMessage(delay, Queue, Msg))
async def get_audio_file_range(loop: AbstractEventLoop):
tasks = []
dtasks = []
for n in range(102, 120):
tasks.append((loop.create_task(get_html(n)), n))
for task, n in tasks:
html = await task
audlink = get_audiolink(html, n)
dtasks.append(loop.create_task(download_file(n, audlink)))
for task in dtasks:
await task
def init(bot: commands.Bot, loop: asyncio.AbstractEventLoop):
async def check_ff20():
vandiland: discord.Guild = bot.get_guild(staticconfig.Vandiland.gid)
emoji_kekban_emoji: discord.Emoji = await vandiland.fetch_emoji(staticconfig.Vandiland.emoji_kekban)
forums_channel: discord.TextChannel = vandiland.get_channel(staticconfig.Vandiland.forums_channel_id)
while True:
await check_league_incidents_vandiland(forums_channel, emoji_kekban_emoji)
await asyncio.sleep(staticconfig.delay_refresh * 4)
loop.create_task(check_ff20())
async def main(loop: asyncio.AbstractEventLoop):
# 컨디션 생성
condition = asyncio.Condition()
# 컨디션을 감시하는 작업 설정
consumers = [consumer(condition, i) for i in range(5)]
# 컨디션 변수를 처리하기 위한 작업 예약
loop.create_task(manipulate_condition(condition))
# consumer들의 완료를 대기
await asyncio.wait(consumers)
async def _accept_loop(server_sock, read_loop_fn,
ev_loop: asyncio.AbstractEventLoop,
protocol_class: Type[BaseProtocol], protocol_args: list,
protocol_kwargs: dict):
while True:
client_sock, _addr = await ev_loop.sock_accept(server_sock)
proto = protocol_class(*protocol_args, **protocol_kwargs)
peer_name = client_sock.getpeername()
LOG.debug("Incoming from %s", peer_name)
proto.on_connected(peer_name)
ev_loop.create_task(
read_loop_fn(proto=proto, sock=client_sock, ev_loop=ev_loop))
async def async_iterator(application: Gtk.Application,
loop: asyncio.AbstractEventLoop) -> None:
while Gtk.events_pending():
Gtk.main_iteration_do(False)
await asyncio.sleep(0.01)
if application.main_window and application.main_window.get_realized():
loop.create_task(async_iterator(application, loop))
else:
application.quit()
loop.stop()
def __init__(
self,
input: asyncio.StreamReader,
output: asyncio.StreamWriter,
loop: asyncio.AbstractEventLoop,
) -> None:
super().__init__()
self._input: asyncio.StreamReader = input
self._output: asyncio.StreamWriter = output
self.loop: asyncio.AbstractEventLoop = loop
self.on_message = lambda _: None
loop.create_task(self._run())
def waitForEvent(emitter: EventEmitter, eventName: str, # noqa: C901
predicate: Callable[[Any], bool], timeout: float,
loop: asyncio.AbstractEventLoop) -> Awaitable:
"""Wait for an event emitted from the emitter."""
promise = loop.create_future()
def resolveCallback(target: Any) -> None:
promise.set_result(target)
def rejectCallback(exception: Exception) -> None:
promise.set_exception(exception)
async def timeoutTimer() -> None:
await asyncio.sleep(timeout / 1000)
rejectCallback(
TimeoutError('Timeout exceeded while waiting for event'))
def _listener(target: Any) -> None:
if not predicate(target):
return
cleanup()
resolveCallback(target)
listener = addEventListener(emitter, eventName, _listener)
if timeout:
eventTimeout = loop.create_task(timeoutTimer())
def cleanup() -> None:
removeEventListeners([listener])
if timeout:
eventTimeout.cancel()
return promise
async def total(loop: asyncio.AbstractEventLoop):
"""
asdf asd f asd f asd f asdf
.. note:
asdfasdfas df as df
>>> a = 1
>>> int(a)
1
@param loop: asdfasdf as df asdf
:param loop:
:type loop:
:return:
:rtype:
"""
t = []
sem = asyncio.Semaphore(10, loop=loop)
for x in range(1000):
await sem.acquire()
t.append(loop.create_task(hello(x, sem)))
return t
def run_until_complete(coro: Awaitable, loop: AbstractEventLoop=None):
"""Run a task through to completion.
The ``.run_until_complete()`` method on asyncio event loop objects does not
finish tasks when it receives a SIGINT/CTRL-C. The method simply raises a
``KeyboardInterrupt`` exception and this usually results in warnings about
unfinished tasks plus some "event loop closed" ``RuntimeError`` exceptions
in pending tasks.
This is a really annoying default behavior and this function aims at
replacing that behavior with something that ensures the task actually runs
through to completion. When the ``KeyboardInterrupt`` exception is caught,
the task is canceled and resumed to give it a chance to clean up properly.
.. versionadded:: 0.4
.. versionchanged:: 0.5 Can now be called with a ``asyncio.Task`` argument.
"""
loop = loop or asyncio.get_event_loop()
if isinstance(coro, asyncio.Task):
task = coro
else:
task = loop.create_task(coro)
try:
loop.run_until_complete(task)
except KeyboardInterrupt:
task.cancel()
try:
loop.run_until_complete(task)
except asyncio.CancelledError:
return None
return task.result()
async def _scan(targets: Set[str],
ports: Set[int],
config: DockerScanModel,
loop: asyncio.AbstractEventLoop):
max_concurrency = asyncio.BoundedSemaphore(int(config.concurrency),
loop=loop)
results = []
tasks = []
for target in targets:
for port in ports:
await max_concurrency.acquire()
tasks.append(loop.create_task(_check_ports(
target,
port,
loop,
max_concurrency,
results,
config
)))
await asyncio.wait(tasks, loop=loop)
return results
def __init__(
self,
name: str,
offset: Position,
size: Dimensions,
loop: asyncio.AbstractEventLoop,
actions: Dict[UIActionEnum, actions.Action] = None,
) -> None:
self.name = name
self.size = size
self.offset = offset
self.loop = loop
self.busy = False
self.children = set() # type: Set[UIComponent]
self.actions = actions if actions is not None else {}
for action in self.actions.values():
action.set_source(self)
self.parent = None # type: UIComponent
if loop is not None:
qsize = self.ACTION_QUEUE_SIZE
self._action_queue = asyncio.Queue(qsize) # type: asyncio.Queue
self._action_runner = loop.create_task(self._process_actions())
self._action_queue_get = None # type: asyncio.Future
self._current_action = None # type: UIActionEnum
self._nw_corner = offset - Position(1, 1)
self._se_corner = Position(
x=self.offset.x + self.size.width - 1,
y=self.offset.y + self.size.height - 1,
)
async def get_address(self, loop: asyncio.AbstractEventLoop) -> SocketAddress:
server = ThriftServer(Handler(), port=0)
serve_task = loop.create_task(server.serve())
addy = await server.get_address()
server.stop()
await serve_task
return addy
async def start_lightsd_connection(
loop: asyncio.AbstractEventLoop,
lightsd_url: str,
refresh_delay_s: float = DEFAULT_REFRESH_DELAY,
) -> None:
global _refresh_task, lightsd
lightsd = await lightsc.create_async_lightsd_connection(lightsd_url)
_refresh_task = loop.create_task(_poll(loop, refresh_delay_s))
