def __init__(self, id=None, config={}, hw_metadata={}): EventEmitter.__init__(self) self.id = id self.config = config self.status = None self.device_timeout = config.get('max_time_since_last_seen', 300) self._timeout_expect_new_status = None
class PyrebaseDatabase(object): def __init__(self): with open('pyrebase_config.json') as f: config = json.load(f) #print() self.firebase = pyrebase.initialize_app(config) self.db = self.firebase.database() def start(self): self.ee = EventEmitter() self.new_data_listener(self.new_data_handler) self.my_stream = self.db.child("users").child("0").stream( self.stream_handler) def stop(self): print('closing stream to firebase') self.my_stream.close() def stream_handler(self, message): print(message["event"]) # put print(message["path"]) # /-K7yGTTEp7O549EzTYtI print(message["data"]) # {'title': 'Pyrebase', "body": "etc..."} s = json.dumps(message["data"]) self.ee.emit("new_data_event", s) def new_data_handler(self, args): print(args) def new_data_listener(self, func): self.ee.on("new_data_event", func)
class PyrebaseDatabase(object): def __init__(self): with open( '/home/pi/Documents/american_gothic/american_gothic_1/python/pyrebase_config.json' ) as f: config = json.load(f) #print() self.firebase = pyrebase.initialize_app(config) self.db = self.firebase.database() def start(self, node): self.ee = EventEmitter() self.new_data_listener(self.new_data_handler) self.my_stream = self.db.child(node).stream(self.stream_handler) def stop(self): print('closing stream to firebase') self.my_stream.close() def stream_handler(self, message): print(message["event"]) # put print(message["path"]) # /-K7yGTTEp7O549EzTYtI print(message["data"]) # {'title': 'Pyrebase', "body": "etc..."} s = json.dumps(message["data"]) self.ee.emit("new_data_event", s) def new_data_handler(self, args): print(args) def new_data_listener(self, func): self.ee.on("new_data_event", func) def send_data(self, data): self.db.child("american_gothic").update({"buffer_1": data})
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
class Speed(): def __init__(self): self.sl = SpeedListener() self.ee = EventEmitter() self.sl.setEM(self.ee) self.channel = None self.running = True def em(self): return self.ee def start(self): logging.debug('Starting bike events listener') # Initialize stick = driver.USB1Driver(SERIAL, log=LOG, debug=DEBUG) self.antnode = node.Node(stick) self.antnode.start() self.antnode.registerEventListener(self.sl) # Set network key network = node.Network(key=NETKEY, name='N:ANT+') self.antnode.setNetworkKey(0, network) # Get the first unused channel. Returns an instance of the node.Channel class. self.channel = self.antnode.getFreeChannel() # Initialize it as a receiving channel using our network key self.channel.assign(network, CHANNEL_TYPE_TWOWAY_RECEIVE) # Now set the channel id for pairing with an ANT+ HR monitor self.channel.setID(123, 0, 0) # Listen forever and ever (not really, but for a long time) self.channel.searchTimeout = TIMEOUT_NEVER # We want a ~4.06 Hz transmission period self.channel.period = 8118 # And ANT frequency 57 self.channel.frequency = 57 self.evm = event.EventMachine(driver) self.channel.open() self.ee.emit("connected", True) def stop(self): logging.info("Closing devices finally") if self.channel is None: return None # Shutdown channel self.channel.close() self.channel.unassign() # Shutdown self.antnode.stop()
def __init__(self, host, port): self._host = host self._port = port self._error = None self._connect_called = False asyncore.dispatcher.__init__(self) EventEmitter.__init__(self) self.create_socket(socket.AF_INET, socket.SOCK_STREAM)
def __init__(self, host='0.0.0.0', port=1234, tcp_backlog=20): asyncore.dispatcher.__init__(self) EventEmitter.__init__(self) self.create_socket(socket.AF_INET, socket.SOCK_STREAM) self.set_reuse_addr() self.bind((host, port)) self.listen(tcp_backlog) self.clients = {}
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 __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 createFactorDartListener(self, ee: EventEmitter) -> None: ee.on(EVENT_DART_API_CRAWLING_ON_DOWNLOADING_CODES, self.onDownloadingCodes) ee.on(EVENT_DART_API_CRAWLING_ON_CRAWLING_FACTOR_DATA, self.onCrawlingFactorData) ee.on(EVENT_DART_API_CRAWLING_ON_COMPLETE_YEAR, self.onCompleteYear) ee.on(EVENT_DART_API_CRAWLING_ON_RESULT_OF_FACTOR, self.onResultOfFactor) ee.on(EVENT_DART_API_CRAWLING_ON_CANCEL, self.onCancelled)
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_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, *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) self.stack = []
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()
class Main(): """ Python-Main class """ _instance = None EVENT_RELOAD = "reload" @classmethod def i(cls): if cls._instance is None: cls._instance = cls() return cls._instance ####################################################### 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 reload(self): self.ee.emit(Main.EVENT_RELOAD) def __postinit(self): """ Post-init for everything that needs a ready main instance. """ if self.__pi_done: return self.config = JSON_File("config/settings.json") self.igp = [] @self.config.ee.on(JSON_File.EVENT_RELOAD) def _on_config_reload(cfg): self.igp = [re.compile(r) for r in cfg["ignore-pattern"]] self.__pi_done = True self.reload() def run(self): self.__postinit() from bot_modules import load load() self.bot.run(self.config["token"])
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 __init__(self, ttl=None): EventEmitter.__init__(self) self.fd = None self.ip = None self.port = None self.timeout = None self.socket = None self.connected = False self.connecting = False self.error = None self.buffer = bytearray() self.ttl = ttl self.ttl_timeout = None
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")
class Receiver: def __init__(self, *args, **kwargs): self.queue = kwargs.pop("__queue") self.event_emitter = EventEmitter() def on(self, event_str, lambda_func): self.event_emitter.on(event_str, lambda: lambda_func()) async def start(self, port): q = self.queue e = self.event_emitter # look at all network interfaces await (asyncio.get_event_loop()).create_server( protocol_factory=lambda: EventProtocol(q, e), host=None, port=port)
def __init__(self, sock, server): self.id = sock.fileno() debug("INFO", "NEW CLIENT: ", self.id) self.server = server self.request = None self.proto = None self.status = "alive" self.processing = False self.client_id = None self.session_id = None asyncore.dispatcher_with_send.__init__(self, sock) EventEmitter.__init__(self) # Proxy 'request' event to self.on('request', self.process_request)
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")
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)
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 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 __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_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 __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): 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 __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, id=None, config={}, hw_metadata={}): EventEmitter.__init__(self) self.id = id self.config = config self.key = config.get('key', None) self.ip = config.get('ip', hw_metadata.get('ip', None)) self.port = config.get('port', 6668) self.socket_timeout = config.get('socket_timeout', 10) self.command_timeout = config.get('command_timeout', 5) self.version = float(hw_metadata.get('version', '3.3')) self.active = hw_metadata.get('active', None) self.ablilty = hw_metadata.get('ablilty', None) self.encrypt = hw_metadata.get('encrypt', None) self.product_key = hw_metadata.get('productKey', None) self.gw_id = hw_metadata.get('gwId', None) self.dps = str(config.get('dps', 1)) self.persistent_connections = config.get('persistent_connections', False) self.get_status_on_start = config.get('get_status_on_start', True) # Creates the connection object and sets event handlers self.connection = AsyncSocketClient(ttl=config.get('socket_ttl', 300)) self.connection.on('connect', self._on_dev_connect) self.connection.on('failure', self._on_dev_connection_failure) self.connection.on('timeout', self._on_dev_connection_failure) self.connection.on('break', self._on_dev_connection_break) self.connection.on('disconnect', self._on_dev_disconnect) self.connection.on('exception', self._on_dev_exception) self.connection.on('error', self._on_dev_error) self.connected = False self.connecting = False self.sync_proto = SyncProto( self.connection, self._encode_and_send_message, self._read_and_parse_message, ) self.sync_proto.on('drain', self._on_dev_send_drain) self.sync_proto.on('send_error', self._on_dev_send_error) self.sync_proto.on('receive_error', self._on_dev_recv_error) # When IP address changes self.on('_ip', self._on_ip_change) # Connect to the device right away if persistent_connections is ON if self.gw_id and self.ip: self.emit('_ip')
class MockedSpeed(): def __init__(self): self.ee = EventEmitter() self.running = True def em(self): return self.ee def start(self): logging.debug('Starting bike events listener') try: logging.info("Listening for device events...") while self.running: self.ee.emit("speed", SpeedEvent(10, 2.3456)) time.sleep(5) finally: self.running = False def stop(self): self.running = False
def __init__(self): self.sl = SpeedListener() self.ee = EventEmitter() self.sl.setEM(self.ee) self.channel = None self.running = True
class AllTestCase(unittest.TestCase): 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) self.stack = [] def test_1_callback_usage(self): def handler(arg): self.stack.append("1_callback_usage_" + arg) self.ee1.on("1_callback_usage", handler) self.ee1.emit("1_callback_usage", "foo") self.assertTrue(self.stack[-1] == "1_callback_usage_foo") def test_1_decorator_usage(self): @self.ee1.on("1_decorator_usage") def handler(arg): self.stack.append("1_decorator_usage_" + arg) self.ee1.emit("1_decorator_usage", "bar") self.assertTrue(self.stack[-1] == "1_decorator_usage_bar") def test_1_ttl(self): # same as once @self.ee1.on("1_ttl", ttl=1) def handler(arg): self.stack.append("1_ttl_" + arg) self.ee1.emit("1_ttl", "foo") self.assertTrue(self.stack[-1] == "1_ttl_foo") self.ee1.emit("1_ttl", "bar") self.assertTrue(self.stack[-1] == "1_ttl_foo") def test_2_on_all(self): @self.ee2.on("2_on_all.*") def handler(): self.stack.append("2_on_all") self.ee2.emit("2_on_all.foo") self.assertTrue(self.stack[-1] == "2_on_all") def test_2_emit_all(self): @self.ee2.on("2_emit_all.foo") def handler(): self.stack.append("2_emit_all.foo") self.ee2.emit("2_emit_all.*") self.assertTrue(self.stack[-1] == "2_emit_all.foo") def test_3_delimiter(self): @self.ee3.on("3_delimiter:*") def handler(): self.stack.append("3_delimiter") self.ee3.emit("3_delimiter:foo") self.assertTrue(self.stack[-1] == "3_delimiter") def test_4_new(self): @self.ee4.on("new_listener") def handler(func, event=None): self.stack.append((func, event)) def newhandler(): pass self.ee4.on("4_new", newhandler) self.assertTrue(self.stack[-1] == (newhandler, "4_new")) def test_5_max(self): @self.ee5.on("5_max") def handler1(): self.stack.append("5_max_1") @self.ee5.on("5_max") def handler2(): self.stack.append("5_max_2") self.ee5.emit("5_max") self.assertTrue(self.stack[-1] == "5_max_1")
# -*- coding: utf-8 -*- # python imports import os import sys # adjust the path to import pymitter base = os.path.normpath(os.path.join(os.path.abspath(__file__), "../..")) sys.path.insert(0, base) # create an EventEmitter instance from pymitter import EventEmitter ee = EventEmitter(wildcard=True, new_listener=True, max_listeners=-1) @ee.on("new_listener") def on_new(func, event=None): print("added listener", event, func) @ee.on("foo") def handler_foo1(arg): print("foo handler 1 called with", arg) @ee.on("foo") def handler_foo2(arg): print("foo handler 2 called with", arg) @ee.on("foo.*", ttl=1) def handler_fooall(arg): print("foo.* handler called with", arg)
def __init__(self): self.ee = EventEmitter() self.running = True