def __init__(self, *args, **kwargs): super(AllTestCase, self).__init__(*args, **kwargs) self.ee1 = EventEmitter() self.ee2 = EventEmitter(wildcard=True) self.ee3 = EventEmitter(wildcard=True, delimiter=":") self.ee4 = EventEmitter(new_listener=True) self.ee5 = EventEmitter(max_listeners=1)
def __init__(self): if AudioManager.__instance__ is None: AudioManager.__instance__ = self # create event emitter self.ee = EventEmitter() else: raise Exception("You cannot create another AudioManager class")
async def main() -> None: ee = EventEmitter() source = StockCrawlingDataSource(ee) dto = StockCrawlingRunCrawlingDTO.create('http://localhost:4444', "kospi", "20200316", "20210320", "marcap", "marcapkospi2020031620210320") await source.getStockData(dto)
def test_listeners(self): ee = EventEmitter(wildcard=True) @ee.on("foo") def h1(): pass @ee.on("foo") def h2(): pass @ee.on("bar") def h3(): pass @ee.once("baz") def h4(): pass @ee.on_any def h5(): pass self.assertEqual(tuple(ee.listeners_any()), (h5, )) self.assertEqual(tuple(ee.listeners_all()), (h1, h2, h3, h4, h5)) self.assertEqual(tuple(ee.listeners("foo")), (h1, h2)) self.assertEqual(tuple(ee.listeners("bar")), (h3, )) self.assertEqual(tuple(ee.listeners("ba?")), (h3, h4))
def __init__(self, **kwargs): """ Watch(gpio=GPIO, trig=23, echo=24, func_in=None, func_out=None, offset=200) The Watch class. Please always use *kwargs* in the constructor. - *gpio*: Pass the GPIO object - *trig*: Pin for trigger - *echo*: Pin for trigger - *func_in*: handler when a objects comes into field - *func_out*: handler when a objects goes out of field - *offset*: offset in cm to determine if the object is IN zone or OUT zone """ def dummy_func_in(): print("Dummy in function") def dummy_func_out(): print("Dummy out function") super(Watch, self).__init__() func_in = kwargs.get("func_in", dummy_func_in) func_out = kwargs.get("func_out", dummy_func_out) self._ee = EventEmitter(wildcard=True, new_listener=True, max_listeners=-1) self._ee.on("ObjectIn", func_in) self._ee.on("ObjectOut", func_out) self._gpio = kwargs.get("gpio", None) self._trig = kwargs.get("trig", 23) self._echo = kwargs.get("echo", 24) self._offset = kwargs.get("offset", 200) self._wasIn = False self._observer = ThreadPoolExecutor(max_workers=1) self._observer_on = True self._future = None
def test_tree(self): ee = EventEmitter() stack = [] @ee.on("max") def handler1(): stack.append("max_1") @ee.once("max") def handler2(): stack.append("max_2") self.assertEqual(ee.num_listeners, 2) self.assertEqual(len(ee._event_tree.nodes["max"].listeners), 2) ee.emit("max") self.assertTrue(stack[-2] == "max_1") self.assertTrue(stack[-1] == "max_2") del stack[:] ee.emit("max") self.assertTrue(stack[-1] == "max_1") del stack[:] self.assertEqual(ee.num_listeners, 1) self.assertTrue("max" in ee._event_tree.nodes) self.assertEqual(len(ee._event_tree.nodes["max"].listeners), 1) ee.off("max", handler1) self.assertEqual(ee.num_listeners, 0)
def __init__(self, mongod: StockMongoDataSource, tasksRepository: TasksRepository) -> None: super().__init__() self.mongod = mongod self.tasksRepository = tasksRepository self.logger = Logger("StockRepository") self.ee = EventEmitter()
def __init__(self, mongod: TaskMongoDataSource) -> None: super().__init__() self.mongod = mongod self.logger = Logger("TasksRepository") self.taskEventEmitter = EventEmitter() self.tasksdto = ProcessTasks() self.taskRunner: Optional[TaskRunner] = None self.createTaskRunner()
def run(self): # Fired when input is available. self.on_data_received_emitter = EventEmitter() self.on_notification_emitter = EventEmitter() self.on_notification_emitter.on("notify_client", self.notify_client) self.data_processing_unit = data_processing_unit.DataProcessingUnit( self.on_data_received_emitter, self.on_notification_emitter, self.command_set) self.data_processing_unit.start_processing() args = mic_vad_streaming_args.VADArgs( self.model_file, self.scorer_file, self.vad_aggression_factor, self.input_device_index, self.sample_rate, self.file_path, self.nospinner, self.savewav, self.on_data_received_emitter) vadToDeepSpeechTool.main(args)
def test_delimiter(self): ee = EventEmitter(wildcard=True, delimiter=":") stack = [] @ee.on("delimiter:*") def handler(): stack.append("delimiter") ee.emit("delimiter:foo") self.assertTrue(stack[-1] == "delimiter")
def __init__(self, max_timeout=10, name="channelHandler"): self.timeout = max_timeout threading.Thread.__init__(self) self.callbackEmitter = EventEmitter() self.requests = [] self.name = name self.blockNumber = 0 self.onResponsePrefix = "onResponse" self.getResultPrefix = "getResult" self.lock = threading.RLock()
def test_on_all(self): ee = EventEmitter(wildcard=True) stack = [] @ee.on("on_all.*") def handler(): stack.append("on_all") ee.emit("on_all.foo") self.assertTrue(stack[-1] == "on_all")
def test_async_decorator_usage(self): ee = EventEmitter() stack = [] @ee.on("async_decorator_usage") async def handler(arg): stack.append("async_decorator_usage_" + arg) ee.emit("async_decorator_usage", "bar") self.assertTrue(stack[-1] == "async_decorator_usage_bar")
def test_async_callback_usage(self): ee = EventEmitter() stack = [] async def handler(arg): stack.append("async_callback_usage_" + arg) ee.on("async_callback_usage", handler) ee.emit("async_callback_usage", "foo") self.assertTrue(stack[-1] == "async_callback_usage_foo")
async def test_await_async_decorator_usage(self): ee = EventEmitter() stack = [] @ee.on("await_async_decorator_usage") async def handler(arg): stack.append("await_async_decorator_usage_" + arg) res = ee.emit_async("await_async_decorator_usage", "bar") self.assertEqual(len(stack), 0) await res self.assertTrue(stack[-1] == "await_async_decorator_usage_bar")
def test_ttl_once(self): ee = EventEmitter() stack = [] @ee.once("ttl_once") def handler(arg): stack.append("ttl_once_" + arg) ee.emit("ttl_once", "foo") self.assertTrue(stack[-1] == "ttl_once_foo") ee.emit("ttl_once", "bar") self.assertTrue(stack[-1] == "ttl_once_foo")
def __init__(self): log("Constructing Bot") from bot import Bot self.ee = EventEmitter() self.config = object() # __postinit self.igp = [] # __postinit self.bot = Bot() self.__pi_done = False
def setUp(self): self.set_up_env('sqlite') self.env.stats = MockStatsd() self.env.auth = AllowAllAuth() self.env.capture_exception = lambda x: False self.env.observer = EventEmitter() self.env.request = BaseTest.Request(SESSION_ID_ONE) environ.env.request = self.env.request self.db.create_channel(BaseTest.CHANNEL_NAME, BaseTest.CHANNEL_ID, BaseTest.USER_ID) self.db.create_room(BaseTest.ROOM_NAME, BaseTest.ROOM_ID, BaseTest.CHANNEL_ID, BaseTest.USER_ID, BaseTest.USER_NAME)
def __init__(self, configfile='devices.yaml'): stream = open(configfile, 'r') try: self.orig_data = self.load_file(stream, configfile) self.overlay_stack = [] self.__dict__.update(copy.deepcopy(self.orig_data)) finally: stream.close() self.plugin_data = dict() self.orig_data["plugin_data"] = dict() self.event_emitter = EventEmitter()
def test_max(self): ee = EventEmitter(max_listeners=1) stack = [] @ee.on("max") def handler1(): stack.append("max_1") @ee.on("max") def handler2(): stack.append("max_2") ee.emit("max") self.assertTrue(stack[-1] == "max_1")
async def test_await_async_callback_usage(self): ee = EventEmitter() stack = [] async def handler(arg): stack.append("await_async_callback_usage_" + arg) ee.on("await_async_callback_usage", handler) res = ee.emit_async("await_async_callback_usage", "foo") self.assertEqual(len(stack), 0) await res self.assertTrue(stack[-1] == "await_async_callback_usage_foo")
def __init__(self): self.ee = EventEmitter() self.MiNombre = "..." self.MiPuntaje = 0 self.MisCartas = [] self.MiSaldo = 0 self.MiEstado = "" self.Validado = False self.esMiTurno = False self.Turno = "" self.Acciones = [] self.Jugadores = [] self.lenguaje = "es"
def test_on_any(self): ee = EventEmitter() stack = [] @ee.on("foo") def handler1(): stack.append("foo") @ee.on_any() def handler2(): stack.append("bar") ee.emit("foo") self.assertEqual(tuple(stack), ("foo", "bar"))
def test_off_all(self): ee = EventEmitter() @ee.on_any def handler1(): pass @ee.on("foo") def handler2(): pass self.assertEqual(ee.num_listeners, 2) ee.off_all() self.assertEqual(ee.num_listeners, 0)
def test_new(self): ee = EventEmitter(new_listener=True) stack = [] @ee.on("new_listener") def handler(func, event=None): stack.append((func, event)) def newhandler(): pass ee.on("new", newhandler) ee.on_any(newhandler) self.assertTrue(stack[-2] == (newhandler, "new")) self.assertTrue(stack[-1] == (newhandler, None))
def __init__(self, fireAlarmKey, name="default_name", memCacheAddress='127.0.0.1:11211', debug=0): self.name = name self.memCacheAddress = memCacheAddress self.debug = debug #fire alarm event emitter/handler ee = EventEmitter() fireAlarm = FireAlarm(fireAlarmKey, ee) ee.on("fireAlarmEvent", self.handleFireAlarmEvent) fireAlarmProcess = Process(target=fireAlarm.listenKB) fireAlarmProcess.start()
def __init__(self): QWidget.__init__(self) event_emitter = EventEmitter() player = Player() content = self._create_content_layout(event_emitter, player) layout = QGridLayout() layout.addLayout(content, 0, 0) layout.addWidget(PlayerInfoView(event_emitter, player), 1, 0) layout.setRowStretch(0, 10) layout.setRowStretch(1, 1) self.setLayout(layout) self.setObjectName('main') self.setStyleSheet(Stylist().get_style_sheet())
def test_off_any(self): ee = EventEmitter() stack = [] @ee.on_any def handler1(): stack.append("foo") ee.emit("xyz") self.assertEqual(tuple(stack), ("foo", )) del stack[:] ee.off_any(handler1) ee.emit("xyz") self.assertEqual(tuple(stack), ()) self.assertEqual(ee.num_listeners, 0)
def __init__(self, url, user, password, encoding, update_interval, is_daemon=False) -> None: Thread.__init__(self) self.event_listener = EventListener(EventEmitter()) self.daemon: bool = is_daemon self.prevent_updates: bool = False self.update_interval: int = update_interval self.url: str = url self.user: str = user self.password: str = password self.encoding: str = encoding self.existing_data_objects: dict[str, Security] = {} self.create_connection() self.start()
def __init__(self, fireAlarmKey, name="default_name", port=11211, debug=0): self.name = name #fire alarm event emitter/handler self.ee = EventEmitter() self.fireAlarm = FireAlarm(fireAlarmKey, self.ee) self.ee.on("fireAlarmEvent", self.handleFireAlarmEvent) self.fireAlarmProcess = Process(target=self.fireAlarm.listenKB, args=()) self.fireAlarmProcess.start() #shared memory address = '127.0.0.1:' + str(port) self.sharedMemory = memcache.Client([address], debug=debug) #to see full debug logs self.debug = debug == 1