def __init__(self, shared_secret: str, loop: asyncio.AbstractEventLoop) -> None: self.app = web.Application() self.ready_wait = loop.create_future() self.secret_key = "".join( random.choices(string.ascii_lowercase + string.digits, k=64)) self.shared_secret = shared_secret for path in ("whoami", "login", "login/prepare", "login/2fa", "login/check_approved", "login/approved", "logout", "disconnect", "reconnect", "refresh"): self.app.router.add_options(f"/api/{path}", self.login_options) self.app.router.add_get("/api/whoami", self.status) self.app.router.add_post("/api/login/prepare", self.login_prepare) self.app.router.add_post("/api/login", self.login) self.app.router.add_post("/api/login/2fa", self.login_2fa) self.app.router.add_get("/api/login/check_approved", self.login_check_approved) self.app.router.add_post("/api/login/approved", self.login_approved) self.app.router.add_post("/api/logout", self.logout) self.app.router.add_post("/api/disconnect", self.disconnect) self.app.router.add_post("/api/reconnect", self.reconnect) self.app.router.add_post("/api/refresh", self.refresh) self.app.router.add_static( "/", pkg_resources.resource_filename("mautrix_facebook.web", "static/"))
def _exec_listener_thread_safe(loop: AbstractEventLoop, listener: ListenerCb[K], context: Context, event_instance: K) -> "Future[None]": # Create an internal future to better control the listener result result_future: "Future[None]" = loop.create_future() listener_loop = retrieve_loop_from_listener(listener) or loop if loop is listener_loop: context.run( _exec_listener, loop, result_future.cancel, result_future.set_exception, result_future.set_result, listener, event_instance, ) else: listener_loop.call_soon_threadsafe( context.run, _exec_listener, listener_loop, partial(loop.call_soon_threadsafe, result_future.cancel), partial(loop.call_soon_threadsafe, result_future.set_exception), partial(loop.call_soon_threadsafe, result_future.set_result), listener, event_instance, ) return result_future
def __init__(self, dt: datetime.datetime, *, loop: asyncio.AbstractEventLoop) -> None: self.loop: asyncio.AbstractEventLoop = loop self.future: asyncio.Future[None] = loop.create_future() relative_delta = discord.utils.compute_timedelta(dt) self.handle = loop.call_later(relative_delta, self.future.set_result, True)
def __init__(self, loop: AbstractEventLoop, response: bytes) -> None: """Initialize the state response message.""" super().__init__(loop, response, ResponseMessageType.STATE) self._power_consumption = 0 self._electric_current = 0.0 self._init_future = loop.create_future() ensure_future(self.initialize(response), loop=loop)
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
def __init__( self, dispatcher_fiber: Any, object_factory: Callable[[ChannelOwner, str, str, Dict], ChannelOwner], transport: Transport, loop: asyncio.AbstractEventLoop, ) -> None: super().__init__() self._dispatcher_fiber = dispatcher_fiber self._transport = transport self._transport.on_message = lambda msg: self.dispatch(msg) self._waiting_for_object: Dict[str, Callable[[ChannelOwner], None]] = {} self._last_id = 0 self._objects: Dict[str, ChannelOwner] = {} self._callbacks: Dict[int, ProtocolCallback] = {} self._object_factory = object_factory self._is_sync = False self._child_ws_connections: List["Connection"] = [] self._loop = loop self.playwright_future: asyncio.Future[ "Playwright"] = loop.create_future() self._error: Optional[BaseException] = None self.is_remote = False self._init_task: Optional[asyncio.Task] = None
def __init__(self, loop: asyncio.AbstractEventLoop): self._std: Dict[int, asyncio.StreamReader] = { self._stdout: asyncio.StreamReader(loop=loop), self._stderr: asyncio.StreamReader(loop=loop), } self.process_end_waiter: asyncio.Future[None] = loop.create_future()
def __init__(self, correlation_id: bytes, loop: asyncio.AbstractEventLoop) -> None: self.correlation_id = correlation_id self.headers = None # Create a future for sending the result self._future = loop.create_future() self._loop = loop self._chunks = None self._has_more = False self.data = None
async def test_event_client_once_cb(self, mr_clean: Cleaner, event_loop: AbstractEventLoop): future = event_loop.create_future() client = await connect(url=self.wsurl) mr_clean.add_disposable(client) client.once("Network.requestWillBeSent", lambda x: future.set_result(x)) await client.Network.enable() await client.Page.navigate("https://google.com") assert await future is not None
def _add_signal_handlers(loop: AbstractEventLoop) -> "Future[Any]": """Add signal handlers so shutdown can be handled normally, returning the stop future.""" log.info("Adding signal handlers...") stop = loop.create_future() for sig in SHUTDOWN_SIGNALS: if sys.platform == "win32": signal.signal(sig, lambda s, f: stop.set_result(None)) else: loop.add_signal_handler(sig, stop.set_result, None) return stop
async def threadsafe_partitions_assigned( self, receiver_loop: asyncio.AbstractEventLoop, assigned: Set[TP]) -> None: promise = await self._method_queue.call( receiver_loop.create_future(), self.on_partitions_assigned, assigned, ) # wait for main-thread to finish processing request await promise
def __init__( self, queue: asyncio.Queue, # type: ignore loop: asyncio.AbstractEventLoop, ): self._loop = loop self._queue = queue self._close_event = loop.create_future() # suppress Future exception was never retrieved self._close_event.add_done_callback(lambda f: f.exception())
def create_future(loop: asyncio.AbstractEventLoop) -> asyncio.Future: """ Return a Future, using the loop if possible. loop.create_future() is better, but was only added in Python 3.5.2, see: https://docs.python.org/3/library/asyncio-eventloop.html#asyncio.AbstractEventLoop.create_future """ if hasattr(loop, 'create_future'): return loop.create_future() return asyncio.Future(loop=loop)
async def threadsafe_partitions_revoked( self, receiver_loop: asyncio.AbstractEventLoop, revoked: Set[TP]) -> None: """Call rebalancing callback in a thread-safe manner.""" promise = await self._method_queue.call( receiver_loop.create_future(), self.on_partitions_revoked, revoked, ) # wait for main-thread to finish processing request await promise
def __init__( self, loop: asyncio.AbstractEventLoop, logger: logging.Logger, probe_routine: Callable[[], Awaitable[bool]] ): """ Base class for Java subprocess communication. It's used to automatically relay logs to python's logging framework and to automatically check the process' status. :param loop: The asyncio event loop to use for communicating with this component. If `None` then the running loop within the active thread will be used or a new one will be created if there is no running loop. :param logger: The logger used to relay the subprocess logs and to log other events. :param probe_routine: The coroutine that's used to asynchronously check if the subprocess is ready. """ super().__init__() self.loop = loop self.startup_complete = loop.create_future() self.disconnected = loop.create_future() self.exited = loop.create_future() self._logger = logger self._probe = probe_routine
def wrap_to_future(loop: asyncio.AbstractEventLoop, func: Callable[..., T], *args: Any, **kwargs: Any) -> asyncio.Future: future = loop.create_future() def _inner(): # type: ignore try: return future.set_result(func(*args, **kwargs)) except Exception as e: return future.set_exception(e) loop.call_soon(_inner) return future
def __init__(self, loop: asyncio.AbstractEventLoop) -> None: # Store a reference to loop to avoid relying on self.server._loop. self.loop = loop # Keep track of active connections. self.websockets: Set[WebSocketServerProtocol] = set() # Task responsible for closing the server and terminating connections. self.close_task: Optional[asyncio.Task[None]] = None # Completed when the server is closed and connections are terminated. self.closed_waiter: asyncio.Future[None] = loop.create_future()
async def test_async_set_color_lights(event_loop: asyncio.AbstractEventLoop, MockConnectedGateway): mode = 7 result = event_loop.create_future() result.set_result(b"") with patch( "screenlogicpy.requests.lights.ScreenLogicProtocol.await_send_message", return_value=result, ) as mockRequest: gateway = MockConnectedGateway assert await gateway.async_set_color_lights(mode) await gateway.async_disconnect() assert mockRequest.call_args.args[0] == 12556 assert mockRequest.call_args.args[1] == struct.pack("<II", 0, mode)
def __init__(self, loop: AbstractEventLoop, idx: int, schedule_details: List[bytes]) -> None: """Initialize the schedule.""" self._loop = loop self._enabled = False self._recurring = False self._schedule_id = str(int(schedule_details[idx][0:2], 16)) self._days = [] # type: List[str] self._schedule_data = b"" self._start_time = WAITING_TEXT self._end_time = WAITING_TEXT self._duration = WAITING_TEXT self._init_future = loop.create_future() ensure_future(self.initialize(idx, schedule_details), loop=loop)
async def test_event_client_on_cb(self, mr_clean: Cleaner, event_loop: AbstractEventLoop): future = event_loop.create_future() client = await connect(url=self.wsurl, remote=True) mr_clean.add_disposable(client) def listener(x): if not future.done(): future.set_result(x) client.on("Network.requestWillBeSent", listener) await client.Network.enable() await client.Page.navigate("https://google.com") assert await future is not None
async def test_async_set_scg_config(event_loop: asyncio.AbstractEventLoop, MockConnectedGateway): pool_output = 50 spa_output = 0 result = event_loop.create_future() result.set_result(b"") with patch( "screenlogicpy.requests.heat.ScreenLogicProtocol.await_send_message", return_value=result, ) as mockRequest: gateway = MockConnectedGateway assert await gateway.async_set_scg_config(pool_output, spa_output) await gateway.async_disconnect() assert mockRequest.call_args.args[0] == 12576 assert mockRequest.call_args.args[1] == struct.pack( "<IIIII", 0, pool_output, spa_output, 0, 0)
async def test_async_set_circuit(event_loop: asyncio.AbstractEventLoop, MockConnectedGateway): circuit_id = 505 circuit_state = 1 result = event_loop.create_future() result.set_result(b"") with patch( "screenlogicpy.requests.button.ScreenLogicProtocol.await_send_message", return_value=result, ) as mockRequest: gateway = MockConnectedGateway assert await gateway.async_set_circuit(circuit_id, circuit_state) await gateway.async_disconnect() assert mockRequest.call_args.args[0] == 12530 assert mockRequest.call_args.args[1] == struct.pack( "<III", 0, circuit_id, circuit_state)
async def test_async_set_heat_temp(event_loop: asyncio.AbstractEventLoop, MockConnectedGateway): body = 0 temp = 88 result = event_loop.create_future() result.set_result(b"") with patch( "screenlogicpy.requests.heat.ScreenLogicProtocol.await_send_message", return_value=result, ) as mockRequest: gateway = MockConnectedGateway assert await gateway.async_set_heat_temp(body, temp) await gateway.async_disconnect() assert mockRequest.call_args.args[0] == 12528 assert mockRequest.call_args.args[1] == struct.pack( "<III", 0, body, temp)
async def test_connects_and_emits_closed_after_dispose_supplied_url( self, event_loop: AbstractEventLoop ): future = event_loop.create_future() client = await connect(url="http://localhost:9222") def cb(): if not future.done(): future.set_result(True) client.set_close_callback(cb) async with timeout(10, loop=event_loop): await client.dispose() async with timeout(10, loop=event_loop): assert await future
async def start_tls( loop: asyncio.AbstractEventLoop, transport: asyncio.Transport, protocol: asyncio.Protocol, sslcontext: ssl.SSLContext, server_side: bool = False, server_hostname: Optional[str] = None, ssl_handshake_timeout: Optional[Union[float, int]] = None, ) -> asyncio.Transport: # We use hasattr here, as uvloop also supports start_tls. if hasattr(loop, "start_tls"): return await loop.start_tls( # type: ignore transport, protocol, sslcontext, server_side=server_side, server_hostname=server_hostname, ssl_handshake_timeout=ssl_handshake_timeout, ) waiter = loop.create_future() ssl_protocol = SSLProtocol(loop, protocol, sslcontext, waiter, server_side, server_hostname) # Pause early so that "ssl_protocol.data_received()" doesn't # have a chance to get called before "ssl_protocol.connection_made()". transport.pause_reading() # Use set_protocol if we can if hasattr(transport, "set_protocol"): transport.set_protocol(ssl_protocol) # type: ignore else: transport._protocol = ssl_protocol # type: ignore conmade_cb = loop.call_soon(ssl_protocol.connection_made, transport) resume_cb = loop.call_soon(transport.resume_reading) try: await asyncio.wait_for(waiter, timeout=ssl_handshake_timeout) except Exception: transport.close() conmade_cb.cancel() resume_cb.cancel() raise return ssl_protocol._app_transport
def __init__(self, loop: AbstractEventLoop, message: Union[bytes, str]) -> None: """Initialize the broadcast message.""" self._loop = loop self._verified = self._validated = False self._power_consumption = 0 self._electric_current = 0.0 self._ip_address = WAITING_TEXT self._mac_address = WAITING_TEXT self._name = WAITING_TEXT self._device_id = WAITING_TEXT self._auto_off_set = WAITING_TEXT self._remaining_time_to_off = WAITING_TEXT self._init_future = loop.create_future() fixed_msg = (message if isinstance(message, bytes) else message.encode(ENCODING_CODEC)) ensure_future(self.initialize(fixed_msg), loop=loop)
def __init__(self, loop: asyncio.AbstractEventLoop) -> None: self.stack_trace: traceback.StackSummary = traceback.StackSummary() self.future = loop.create_future() # The outer task can get cancelled by the user, this forwards the cancellation to the inner task. current_task = asyncio.current_task() def cb(task: asyncio.Task) -> None: if current_task: current_task.remove_done_callback(cb) if task.cancelled(): self.future.cancel() if current_task: current_task.add_done_callback(cb) self.future.add_done_callback( lambda _: current_task.remove_done_callback(cb) if current_task else None)
async def _shutdown_default_executor(loop: asyncio.AbstractEventLoop) -> None: """Backport of cpython 3.9 schedule the shutdown of the default executor.""" future = loop.create_future() def _do_shutdown() -> None: try: loop._default_executor.shutdown(wait=True) # type: ignore # pylint: disable=protected-access loop.call_soon_threadsafe(future.set_result, None) except Exception as ex: # pylint: disable=broad-except loop.call_soon_threadsafe(future.set_exception, ex) thread = threading.Thread(target=_do_shutdown) thread.start() try: await future finally: thread.join()
async def test_event_on_cb_removable(self, mr_clean: Cleaner, event_loop: AbstractEventLoop): future = event_loop.create_future() client: Client = await connect(url=self.wsurl) mr_clean.add_disposable(client) def listener(x): if not future.done(): future.set_result(x) remove = client.Network.requestWillBeSent(listener) assert remove is not None and callable(remove) await client.Network.enable() await client.Page.navigate("https://google.com") assert await future is not None remove() assert len(client.listeners("Network.requestWillBeSent")) == 0
async def test_connects_and_emits_closed_after_dispose_default_url( self, mr_clean: Cleaner, event_loop: AbstractEventLoop ): future = event_loop.create_future() client = await connect() def listener(): if not future.done(): future.set_result(True) mr_clean.addEventListener(client, ConnectionEvents.Disconnected, listener) async with timeout(10, loop=event_loop): await client.dispose() async with timeout(10, loop=event_loop): assert await future