def __init__(self, poll_delay: int = 30): AsyncIOEventEmitter.__init__(self) self.poll_delay = poll_delay self.last_poll = 0 self.tx = {} self.medium_fee = 0 self.session = ...
def __init__(self, modules: list, loop, poll_delay: int = 2): """ :param modules: modules to poll :param poll_delay: how long to wait after polling finishes until polling starts again """ self.modules = modules self.poll_delay = poll_delay self.loop = loop AsyncIOEventEmitter.__init__(self, loop=loop)
def __init__(self, options: PuppetMockOptions, name: str = 'puppet-mock'): super().__init__(options, name) if not options.mocker: raise WechatyPuppetMockError('mocker in options is required') self.mocker: Mocker = options.mocker self.started: bool = False self.emitter = AsyncIOEventEmitter()
def __init__(self, initial_value, value_forwarder=None): """ Initialize the object. initial_value -- the initial value value_forwarder -- the method that updates the actual value on the thing """ EventEmitter.__init__(self) self.last_value = initial_value self.value_forwarder = value_forwarder
def __init__(self, request, signing_secret, app_id, accepted_event_types=_ACCEPTED_EVENT_TYPES): AsyncIOEventEmitter.__init__(self) self.app_id = app_id self.request = request self.event = request['body'] self.signing_secret = signing_secret self.package_info = self.get_package_info() self.accepted_event_types = accepted_event_types
async def init_event_stream ( event_stream : AsyncIOEventEmitter, puppet : PuppetStub, ) -> None: """doc""" async for response in puppet.event(): # print(response) if response is not None: event_type = EventType(response.type).name payload = response.payload # print(event_type, payload) event_stream.emit(event_type, payload)
def peerconn_oniceconnectionstatechange(): state_change = AsyncIOEventEmitter() @state_change.once("failed") async def on_failed(error=None): log.warning( "\n IceConnectionState failed with error %s " "\n Closing connections to peer id %s", error, peerId) self.connection.emit( ConnectionEventType.Error, ConnectionError( f"Negotiation of connection to {peerId} failed.")) await self.connection.close() @state_change.once("closed") def on_closed(): log.info("iceConnectionState is closed, " f"closing connections to {peerId}") self.connection.emit( ConnectionEventType.Error, ConnectionError(f"Connection to {peerId} closed.")) self.connection.close() @state_change.once("disconnected") def on_disconnected(): log.info("iceConnectionState is disconnected, " f"closing connections to {peerId}") self.connection.emit( ConnectionEventType.Error, ConnectionError(f"Connection to {peerId} disconnected.")) self.connection.close() @state_change.once("completed") def on_completed(): log.debug('iceConnectionState completed for peer id %s', peerId) # this function needs to be implemented as in PeerJS # https://github.com/peers/peerjs/blob/5e36ba17be02a9af7c171399f7737d8ccb38fbbe/lib/negotiator.ts#L119 # when the "icecandidate" # event handling issue above is resolved # peerConnection.remove_listener("icecandidate", # peerconn_onicecandidate) pass log.debug('iceConnectionState event: %s', peerConnection.iceConnectionState) # forward connection stage change event to local handlers state_change.emit(peerConnection.iceConnectionState) # notify higher level connection listeners self.connection.emit(ConnectionEventType.IceStateChanged, peerConnection.iceConnectionState)
def __init__(self, initial_value=None, read_forwarder=None, write_forwarder=None): """ Initialize the object. initial_value -- the initial value value_forwarder -- the method that updates the actual value on the thing """ EventEmitter.__init__(self) self._value = initial_value self.read_forwarder = read_forwarder self.write_forwarder = write_forwarder
async def main(): """doc""" channel = Channel(host="127.0.0.1", port=8788) puppet = PuppetStub(channel) event_stream = AsyncIOEventEmitter() event_stream.on('EVENT_TYPE_DONG', \ lambda payload: print('on(dong) %s' % payload)) await asyncio.gather( loop(lambda: puppet.ding(data='haha')), init_event_stream(event_stream, puppet), ) channel.close()
def __init__(self, options: PuppetOptions, name: str = 'puppet_service'): """init PuppetService from options or envrionment Args: options (PuppetOptions): the configuration of PuppetService name (str, optional): [description]. Defaults to 'service_puppet'. Raises: WechatyPuppetConfigurationError: raise Error when configuraiton occur error """ token, endpoint = get_token(), get_endpoint() if not options.token and not token: raise WechatyPuppetConfigurationError( 'wechaty-puppet-service: token not found. please set ' 'environment<WECHATY_PUPPET_SERVICE_TOKEN|TOKEN|token> as token' ) options.token = options.token or token options.end_point = options.end_point or endpoint super().__init__(options, name) self.channel: Optional[Channel] = None self._puppet_stub: Optional[PuppetStub] = None self._event_stream: AsyncIOEventEmitter = AsyncIOEventEmitter() self.login_user_id: Optional[str] = None
async def init_app(aiohttp_client, queue_ttl=30): app = web.Application() app.event_emitter = AsyncIOEventEmitter() # Migration routes as a subapp migration_app = web.Application() MigrationAdminApi(migration_app) app.add_subapp("/migration/", migration_app) # init a db adapter explicitly to be used for the api requests. # Skip all creation processes, these are handled with migration service and init_db db_conf = get_test_dbconf() db = AsyncPostgresDB(name='api') await db._init(db_conf=db_conf, create_triggers=False) cache_store = CacheStore(db=db, event_emitter=app.event_emitter) app.AutoCompleteApi = AutoCompleteApi(app, db) FlowApi(app, db) RunApi(app, db) StepApi(app, db) TaskApi(app, db, cache_store) MetadataApi(app, db) ArtificatsApi(app, db) TagApi(app, db) FeaturesApi(app) PluginsApi(app) LogApi(app, db) CardsApi(app, db) Websocket(app, db, app.event_emitter, queue_ttl) AdminApi(app, cache_store) return await aiohttp_client(app)
def __init__( self, id: str, localId: str, track: MediaStreamTrack, rtpParameters: RtpParameters, stopTracks: bool, disableTrackOnPause: bool, zeroRtpOnPause: bool, rtpSender: Optional[RTCRtpSender] = None, appData: Optional[dict] = None, loop=None ): super(Producer, self).__init__(loop=loop) # Closed flag. self._closed: bool = False # Observer instance. self._observer: AsyncIOEventEmitter = AsyncIOEventEmitter() self._id = id self._localId = localId self._rtpSender = rtpSender self._track = track self._rtpParameters = rtpParameters # NOTE: 'AudioStreamTrack' object has no attribute 'enabled' # self._paused = (not track.enabled) if disableTrackOnPause else False self._paused = False if disableTrackOnPause else False self._maxSpatialLayer: Optional[int] = None self._stopTracks = stopTracks self._disableTrackOnPause = disableTrackOnPause self._zeroRtpOnPause = zeroRtpOnPause self._appData = appData self._handleTrack()
def __init__(self, options: Optional[OfficialAccountPuppetOptions]): if not options: options = OfficialAccountPuppetOptions( app_id=config.app_id, app_secret=config.app_secret, token=config.token, port=config.port) if not options.app_id: raise WechatyPuppetConfigurationError( 'WECHATY_PUPPET_OA_APP_ID environment variable not found') if not options.app_secret: raise WechatyPuppetConfigurationError( 'WECHATY_PUPPET_OA_APP_SECRET environment variable not found') if not options.token: raise WechatyPuppetConfigurationError( 'WECHATY_PUPPET_OA_TOKEN environment variable not found') super().__init__(options, 'puppet-official-account') self.oa: OfficialAccount = OfficialAccount( options=OfficialAccountOption(app_id=options.app_id, app_secret=options.app_secret, port=options.port, token=options.token)) self._event_emitter: AsyncIOEventEmitter = AsyncIOEventEmitter()
def __init__(self, app, db, event_emitter=None): self.event_emitter = event_emitter or AsyncIOEventEmitter() self.db = db self.logger = logging.getLogger("ListenNotify") self.loop = asyncio.get_event_loop() self.loop.create_task(self._init(self.db.pool))
async def test_asyncio_once_emit(event_loop): """Test that EventEmitters also wrap coroutines when using once """ ee = AsyncIOEventEmitter(loop=event_loop) should_call = Future(loop=event_loop) @ee.once('event') async def event_handler(): should_call.set_result(True) ee.emit('event') result = await wait_for(should_call, 0.1) assert result == True
def __init__( self, id: str, input: T, runner: AbstractJobRunner, # TODO: Typing callable kwargs? coro: Callable[[T, Job[T, S], ThreadPoolExecutor], Awaitable[S]], threadpool: Union[ThreadPoolExecutor, None] = None): """Initialises and starts Job :param self: class instance :param id: unique job ID for the runner :param input: input data for the job :param runner: runner in which the job is being executed :param coro: the async function to execute with input and context, returning the result :param threadpool: optional threadpool to pass to coro if supplied """ self.id = id self.input = input self.runner = runner AsyncIOEventEmitter.__init__(self) self.task = create_task(coro(input, self, threadpool=threadpool)) def onTaskDone(task): """Task done handler to publish complete (success) & critical (fail) events""" try: err = task.exception() if (err): self.emit("critical", err) else: result = task.result() self.emit("complete", result) except CancelledError as err: self.emit( "warning", CancelledError("onTaskDone called after task cancelled"). with_traceback(err.__traceback__)) LOGGER.warning("Shouldn't see onTaskDone when cancelled??") except InvalidStateError as err: self.emit( "error", InvalidStateError( "onTaskDone called before task finished: Risk of zombie task" ).with_traceback(err.__traceback__)) self.task.add_done_callback(onTaskDone)
def __init__(self, backtesting=False, symbol='tBTCUSD', indicators={}, logLevel='INFO', exchange_type=ExchangeType.EXCHANGE): self.exchange_type = exchange_type self.marketData = {} self.positions = {} self.lastPrice = {} self.closedPositions = [] self.is_ready = False self.indicators = indicators self.candle_price_key = 'close' self.backtesting = backtesting self.symbol = symbol self.events = AsyncIOEventEmitter() # initialise custom logger self.logLevel = logLevel self.logger = CustomLogger('HFStrategy', logLevel=logLevel) super(Strategy, self).__init__()
async def test_asyncio_emit(event_loop): """Test that AsyncIOEventEmitter can handle wrapping coroutines """ ee = AsyncIOEventEmitter(loop=event_loop) should_call = Future(loop=event_loop) @ee.on('event') async def event_handler(): should_call.set_result(True) ee.emit('event') result = await wait_for(should_call, 0.1) assert result is True
def __init__(self, token, session=None): AsyncIOEventEmitter.__init__(self) self.logger = logging.getLogger('Telegram') self.token = token self.update_id = 0 self.runner = None self.webhook = False self.webhook_url = '' if session is None: self.logger.debug('Creating new session') self.session = aiohttp.ClientSession() self.user_provided_session = False else: self.logger.debug('Using user provided session') self.session = session self.user_provided_session = True
async def test_sync_error(event_loop): """Test that regular functions have the same error handling as coroutines """ ee = AsyncIOEventEmitter(loop=event_loop) should_call = Future(loop=event_loop) @ee.on('event') def sync_handler(): raise PyeeTestError() @ee.on('error') def handle_error(exc): should_call.set_result(exc) ee.emit('event') result = await wait_for(should_call, 0.1) assert isinstance(result, PyeeTestError)
def __init__(self, event_name: str, db, event_emitter=None, cache=None): self.watched = {} # Handle HB Events self.event_emitter = event_emitter or AsyncIOEventEmitter() event_emitter.on(event_name, self.heartbeat_handler) self.db = db self.cache = cache # Start heartbeat watcher self.loop = asyncio.get_event_loop() self.loop.create_task(self.check_heartbeats())
async def test_asyncio_error(event_loop): """Test that AsyncIOEventEmitter can handle errors when wrapping coroutines """ ee = AsyncIOEventEmitter(loop=event_loop) should_call = Future(loop=event_loop) @ee.on('event') async def event_handler(): raise PyeeTestError() @ee.on('error') def handle_error(exc): should_call.set_result(exc) ee.emit('event') result = await wait_for(should_call, 0.1) assert isinstance(result, PyeeTestError)
def __init__(self, name=None, emitter=None, thread_weights=None, executor_factory: _executor_factory_type = None): self.name = name or self.__class__.__name__ self.thread_weights = thread_weights or [1] self._emitter = emitter or AsyncIOEventEmitter() self._flag = ThreadFlag(ThreadFlag.pending) self._handlers: Dict[Callable[..., None], Parameter] = {} self._executor_factory = executor_factory or ( lambda: ThreadPoolExecutor(thread_name_prefix=self.name))
def __init__( self, address: str = None, testnet: bool = False, keepalive: bool = True, loop: asyncio.AbstractEventLoop = None, url: str = None, ) -> None: if not url: self.url = TESTNET_URL if testnet else MAINNET_URL else: self.url = url self.address = address self._session = aiohttp.ClientSession() self._ws: Optional[aiohttp.ClientWebSocketResponse] = None self._loop = loop or asyncio.get_event_loop() self._events = AsyncIOEventEmitter(loop=self._loop) self._sub_queue: List[Tuple[str, dict]] = [] self._keepalive = keepalive self._keepalive_task: Optional[asyncio.Future] = None self._open = False self._testnet = testnet
def __init__( self, token: str, last_date: datetime = None, handlers: List[Handler] = None, webhook_url: str = None, loop=None, emitter: AsyncIOEventEmitter = None, disable_groupfeed: bool = False, disable_mapfeed: bool = False, session=None, ): self._closed = False if not handlers: self.handlers = [] else: self.handlers = handlers self.webhook_url = webhook_url self.apitoken = token self.last_date = last_date or datetime.utcfromtimestamp(0) self.loop = loop or asyncio.get_event_loop() self.last_event = None self.disable_user = disable_groupfeed self.disable_map = disable_mapfeed self.tasks = [] self.session = session or aiohttp.ClientSession() self.api = APIClient(self.session, self.apitoken) self.web = WebClient(self.session, app=self) self.group_ids = [ # https://github.com/ppy/osu-web/blob/master/app/Models/UserGroup.php 4, # GMT 7, # NAT 16, # Alumni 28, # Full BN 32, # Probation BN ] self.last_users = dict() for gid in self.group_ids: self.last_users[gid] = list() self.emitter = emitter or AsyncIOEventEmitter() if handlers: for handler in handlers: handler.register_emitter(self.emitter) handler.app = self
async def test_asyncio_cancellation(event_loop): """Test that AsyncIOEventEmitter can handle Future cancellations""" cancel_me = Future(loop=event_loop) should_not_call = Future(loop=event_loop) ee = AsyncIOEventEmitter(loop=event_loop) @ee.on('event') async def event_handler(): cancel_me.cancel() @ee.on('error') def handle_error(exc): should_not_call.set_result(None) ee.emit('event') try: await wait_for(should_not_call, 0.1) except TimeoutError: pass else: raise PyeeTestError()
def __init__(self, options: PuppetOptions, name: str = 'hostie_puppet'): super().__init__(options, name) if options.token is None: if WECHATY_PUPPET_HOSTIE_TOKEN is None: raise WechatyPuppetConfigurationError('wechaty-puppet-hostie: token not found.') options.token = WECHATY_PUPPET_HOSTIE_TOKEN if options.end_point is None and WECHATY_PUPPET_HOSTIE_ENDPOINT is not None: options.end_point = WECHATY_PUPPET_HOSTIE_ENDPOINT self.channel: Optional[Channel] = None self._puppet_stub: Optional[PuppetStub] = None self._event_stream: AsyncIOEventEmitter = AsyncIOEventEmitter() self.login_user_id: Optional[str] = None
def __init__(self, options: PuppetOptions, name: str = 'padplus_puppet'): super(PadPlusPuppet, self).__init__(options, name) if options.token is None: if WECHATY_PUPPET_PADPLUS_TOKEN is None: raise Exception('wechaty-puppet-hostie: token not found.') options.token = WECHATY_PUPPET_PADPLUS_TOKEN if options.end_point is None \ and WECHATY_PUPPET_PADPLUS_ENDPOINT is not None: options.end_point = WECHATY_PUPPET_PADPLUS_ENDPOINT self.channel: Optional[Channel] = None self.puppet_stub: Optional[PuppetStub] = None self._event_stream: AsyncIOEventEmitter = AsyncIOEventEmitter() self.login_user_id: Optional[str] = None
def __init__(self, app, db, event_emitter=None, queue_ttl: int = WS_QUEUE_TTL_SECONDS, cache=None): self.event_emitter = event_emitter or AsyncIOEventEmitter() self.db = db self.queue = TTLQueue(queue_ttl) self.task_refiner = TaskRefiner( cache=cache.artifact_cache) if cache else None self.artifact_refiner = ArtifactRefiner( cache=cache.artifact_cache) if cache else None self.logger = logging.getLogger("Websocket") event_emitter.on('notify', self.event_handler) app.router.add_route('GET', '/ws', self.websocket_handler) self.loop = asyncio.get_event_loop()
class MockWebsocket(): def __init__(self): self.events = AsyncIOEventEmitter() self.saved_items = [] self.emitted_items = [] def on(self, *args, **kwargs): self.events.on(*args, **kwargs) def once(self, *args, **kwargs): self.events.once(*args, **kwargs) def _emit(self, event, *args, **kwargs): # save published items for testing self.emitted_items += [{ 'time': int(round(time.time() * 1000)), 'data': { 'event': event, 'args': args, 'kwargs': kwargs } }] self.events.emit(event, *args, **kwargs) def remove_all_listeners(self, *args, **kwargs): self.events.remove_all_listeners(*args, **kwargs) def cancel_order(self, *args, **kawargs): pass def submit_order(self, *args, **kawargs): pass def get_emitted_items(self): return self.emitted_items def get_last_emitted_item(self): return self.emitted_items[-1:][0] def get_emitted_items_count(self): return len(self.emitted_items)