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
