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
