busline 0.3.1__py3-none-any.whl → 0.5.1__py3-none-any.whl

busline/event/registry.py

@@ -0,0 +1,67 @@
+from dataclasses import dataclass, field
+from typing import Dict, Type
+
+from busline.event.event import Event
+
+class _Singleton(type):
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        if cls not in cls._instances:
+            cls._instances[cls] = super().__call__(*args, **kwargs)
+        return cls._instances[cls]
+
+
+@dataclass
+class EventRegistry(metaclass=_Singleton):
+    """
+    Registry to manage different event types
+
+    Author: Nicola Ricciardi
+    """
+
+    associations: Dict[str, Type[Event]] = field(default_factory=dict)
+
+    def unregister(self, event_type: str):
+        """
+        Remove an event type association
+        """
+
+        self.associations.pop(event_type)
+
+    def register(self, event_type: str, event_class: Type[Event]):
+        """
+        Add a new association between an event type and an event class
+        """
+
+        self.associations[event_type] = event_class
+
+    def retrive_class(self, event) -> Type[Event]:
+        """
+        Retrive event class of event input based on saved associations and given event type
+
+        KeyError is raised if no association is found
+        """
+
+        return self.associations[event.event_type]
+
+    def convert(self, event: Event, raise_on_miss: bool = True) -> Event:
+        """
+        Convert a generic event, auto-building the right event class based on event type.
+
+        If raise_on_miss=True, a KeyError exception is raised. Otherwise, input is returned in output.
+        """
+
+        if event.event_type not in self.associations and not raise_on_miss:
+            return event
+
+        event_class: Type[Event] = self.retrive_class(event)
+
+        return event_class.from_event(event)
+
+
+
+
+
+
+

busline/event/test.py

@@ -0,0 +1,47 @@
+import unittest
+from typing import Type
+
+from busline.event.event import Event
+from busline.event.registry import EventRegistry
+
+
+class Event1(Event):
+    def my_value1(self) -> int:
+        return self.content
+
+class Event2(Event):
+    def my_value2(self) -> int:
+        return self.content
+
+class TestEventRegistry(unittest.TestCase):
+
+    def test(self):
+
+        event_registry = EventRegistry()    # singleton
+
+        event_registry.register("event1", Event1)
+        event_registry.register("event2", Event2)
+
+        event_registry = EventRegistry()  # singleton
+
+        generic_event1 = Event(content=1, event_type="event1")
+        generic_event2 = Event(content=2, event_type="event2")
+        generic_unknown_event = Event(content=2, event_type="unknown")
+
+        event1: Event1 = event_registry.convert(generic_event1)
+
+        self.assertEqual(event1.event_type, "event1")
+        self.assertEqual(event1.my_value1(), 1)
+
+        event2_class = event_registry.retrive_class(generic_event2)
+
+        self.assertIs(event2_class, Event2)
+
+        event2_class: Type[Event2] = event2_class
+
+        event2 = event2_class.from_event(generic_event2)
+
+        self.assertEqual(event2.event_type, "event2")
+        self.assertEqual(event2.my_value2(), 2)
+
+        self.assertRaises(KeyError, lambda: event_registry.retrive_class(generic_unknown_event))

busline/exceptions.py

@@ -0,0 +1,8 @@
+class TopicNotFound(Exception):
+    pass
+
+class EventBusClientNotConnected(Exception):
+    pass
+
+class EventHandlerNotFound(Exception):
+    pass

busline/local/__init__.py

@@ -0,0 +1,3 @@
+from busline.local.eventbus.async_local_eventbus import AsyncLocalEventBus
+
+DEFAULT_EVENT_BUS_INSTANCE = AsyncLocalEventBus()

busline/local/eventbus/async_local_eventbus.py

@@ -0,0 +1,26 @@
+import logging
+import asyncio
+from dataclasses import dataclass
+from busline.event.event import Event
+from busline.local.eventbus.eventbus import EventBus
+
+
+@dataclass
+class AsyncLocalEventBus(EventBus):
+    """
+    Async local eventbus
+
+    Author: Nicola Ricciardi
+    """
+
+    async def put_event(self, topic: str, event: Event):
+
+        topic_subscriptions = self._get_topic_subscriptions(topic)
+
+        logging.debug(f"new event {event} on topic {topic}, notify subscribers: {topic_subscriptions}")
+
+        tasks = [subscriber.on_event(topic, event) for subscriber in topic_subscriptions]
+
+        await asyncio.gather(*tasks)
+
+            

busline/local/eventbus/eventbus.py

@@ -0,0 +1,86 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+from busline.exceptions import TopicNotFound
+from busline.client.subscriber.subscriber import Subscriber
+from busline.event.event import Event
+
+
+@dataclass
+class EventBus(ABC):
+    """
+    Abstract class used as base for new eventbus implemented in local projects.
+
+    Author: Nicola Ricciardi
+    """
+
+    subscriptions: Dict[str, List[Subscriber]] = field(default_factory=dict)
+
+    def __post_init__(self):
+
+        self.reset_subscriptions()
+
+    def reset_subscriptions(self):
+        self.subscriptions = {}
+
+    @property
+    def topics(self) -> List[str]:
+        return list(self.subscriptions.keys())
+
+    def add_subscriber(self, topic: str, subscriber: Subscriber):
+        """
+        Add subscriber to topic
+
+        :param topic:
+        :param subscriber:
+        :return:
+        """
+
+        self.subscriptions.setdefault(topic, [])
+        self.subscriptions[topic].append(subscriber)
+
+    def remove_subscriber(self, subscriber: Subscriber, topic: Optional[str] = None, raise_if_topic_missed: bool = False):
+        """
+        Remove subscriber from topic selected or from all if topic is None
+
+        :param raise_if_topic_missed:
+        :param subscriber:
+        :param topic:
+        :return:
+        """
+
+        if raise_if_topic_missed and topic is not None and topic not in self.subscriptions.keys():
+            raise TopicNotFound(f"topic '{topic}' not found")
+
+        for name in self.subscriptions.keys():
+
+            if topic is None or self._topic_names_match(topic, name):
+                if subscriber in self.subscriptions[name]:
+                    self.subscriptions[name].remove(subscriber)
+
+
+    def _topic_names_match(self, t1: str, t2: str):
+        return t1 == t2
+
+    def _get_topic_subscriptions(self, topic: str) -> List[Subscriber]:
+
+        topic_subscriptions: List[Subscriber] = []
+        for t, subs in self.subscriptions.items():
+            if self._topic_names_match(t, topic):
+                topic_subscriptions.extend(subs)
+
+        return topic_subscriptions
+
+    @abstractmethod
+    async def put_event(self, topic: str, event: Event):
+        """
+        Put a new event in the bus and notify subscribers of corresponding
+        event's topic
+
+        :param topic:
+        :param event:
+        :return:
+        """
+
+        raise NotImplemented()
+

busline/local/eventbus/local_eventbus.py

@@ -0,0 +1,23 @@
+from busline.event.event import Event
+from busline.local import DEFAULT_EVENT_BUS_INSTANCE
+from busline.local.eventbus.eventbus import EventBus
+
+
+class LocalEventBus(EventBus):
+    """
+    Local *singleton* event bus instance
+
+    Author: Nicola Ricciardi
+    """
+
+    # === SINGLETON pattern ===
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = DEFAULT_EVENT_BUS_INSTANCE # super().__new__(cls)
+
+        return cls._instance
+
+    async def put_event(self, topic: str, event: Event):
+        return self._instance.put_event(topic, event)

busline/local/local_pubsub_client.py

@@ -0,0 +1,54 @@
+from typing import Callable, Optional, Self, override
+from dataclasses import dataclass, field
+from busline.client.publisher.publisher import Publisher
+from busline.client.subscriber.event_handler.closure_event_handler import ClosureEventHandler
+from busline.event.event import Event
+from busline.client.pubsub_client import PubSubClient, PubSubClientBuilder
+from busline.local.eventbus.eventbus import EventBus
+from busline.local.eventbus.local_eventbus import LocalEventBus
+from busline.local.publisher.local_publisher import LocalEventBusPublisher
+from busline.local.subscriber.local_subscriber import LocalEventBusSubscriber
+
+
+@dataclass
+class LocalPubSubClient(PubSubClient):
+    pass
+
+
+@dataclass
+class LocalPubSubClientBuilder(PubSubClientBuilder):
+    """
+    Builder for a local pub/sub client.
+
+    EventBus fed in init will be used to build publishers and subscribers
+
+    Author: Nicola Ricciardi
+    """
+
+    eventbus: EventBus = field(default_factory=LocalEventBus)
+
+    def with_default_publisher(self) -> Self:
+        """"
+        LocalEventBusPublisher coupled with eventbus is used
+        """
+
+        self.base_client.publishers.append(
+            LocalEventBusPublisher(eventbus=self.eventbus)
+        )
+
+        return self
+
+    def with_closure_subscriber(self, closure: Callable[[str, Event], None]) -> Self:
+        self.base_client.subscribers.append(
+            LocalEventBusSubscriber(
+                eventbus=self.eventbus,
+                fallback_event_handler=ClosureEventHandler(closure)
+            )
+        )
+
+        return self
+
+    @override
+    def build(self) -> LocalPubSubClient:
+        return LocalPubSubClient.from_pubsub_client(self.base_client)
+

busline/local/publisher/local_publisher.py

@@ -0,0 +1,38 @@
+import logging
+from typing import override
+
+from busline.client.publisher.publisher import Publisher
+from busline.event.event import Event
+from busline.local.eventbus.eventbus import EventBus
+from busline.exceptions import EventBusClientNotConnected
+from dataclasses import dataclass, field
+
+
+@dataclass
+class LocalEventBusPublisher(Publisher):
+    """
+    Publisher which works with local eventbus, this class can be initialized and used stand-alone
+
+    Author: Nicola Ricciardi
+    """
+
+    eventbus: EventBus
+    connected: bool = field(default=False)
+
+    @override
+    async def connect(self):
+        logging.info(f"publisher {self.identifier} connecting...")
+        self.connected = True
+
+    @override
+    async def disconnect(self):
+        logging.info(f"publisher {self.identifier} disconnecting...")
+        self.connected = False
+
+    @override
+    async def _internal_publish(self, topic_name: str, event: Event, **kwargs):
+
+        if not self.connected:
+            raise EventBusClientNotConnected()
+
+        await self.eventbus.put_event(topic_name, event)

busline/local/subscriber/local_subscriber.py

@@ -0,0 +1,43 @@
+import logging
+from dataclasses import dataclass, field
+from typing import Optional, override
+
+from busline.client.subscriber.topic_subscriber import TopicSubscriber
+from busline.local.eventbus.eventbus import EventBus
+from busline.exceptions import EventBusClientNotConnected
+
+
+@dataclass
+class LocalEventBusSubscriber(TopicSubscriber):
+    """
+    Subscriber topic-based which works with local eventbus
+
+    Author: Nicola Ricciardi
+    """
+
+    eventbus: EventBus
+    connected: bool = field(default=False)
+
+    @override
+    async def connect(self):
+        logging.info(f"subscriber {self.identifier} connecting...")
+        self.connected = True
+
+    @override
+    async def disconnect(self):
+        logging.info(f"subscriber {self.identifier} disconnecting...")
+        self.connected = False
+
+    @override
+    async def _internal_subscribe(self, topic: str, **kwargs):
+        if not self.connected:
+            raise EventBusClientNotConnected()
+
+        self.eventbus.add_subscriber(topic, self)
+
+    @override
+    async def _internal_unsubscribe(self, topic: Optional[str] = None, **kwargs):
+        if not self.connected:
+            raise EventBusClientNotConnected()
+
+        self.eventbus.remove_subscriber(self, topic)

busline/local/test.py

@@ -0,0 +1,156 @@
+import unittest
+
+from busline.client.multiclient import EventBusMultiClient
+from busline.client.subscriber.event_handler.closure_event_handler import ClosureEventHandler
+from busline.local.eventbus.async_local_eventbus import AsyncLocalEventBus
+from busline.local.eventbus.local_eventbus import LocalEventBus
+from busline.local.local_pubsub_client import LocalPubSubClientBuilder
+from busline.local.publisher.local_publisher import LocalEventBusPublisher
+from busline.event.event import Event
+from busline.local.subscriber.local_subscriber import LocalEventBusSubscriber
+
+
+class TestLocalEventBus(unittest.IsolatedAsyncioTestCase):
+
+    async def test_async_eventbus(self):
+
+        local_eventbus_instance1 = LocalEventBus()       # singleton
+        local_eventbus_instance2 = LocalEventBus()       # singleton
+
+        self.assertIs(local_eventbus_instance1, local_eventbus_instance2)        # check singleton
+
+        event = Event()
+        received_event = None
+
+        def callback(t: str, e: Event):
+            nonlocal received_event
+
+            received_event = e
+
+        subscriber = LocalEventBusSubscriber(
+            eventbus=local_eventbus_instance1,
+            fallback_event_handler=ClosureEventHandler(callback)
+        )
+        publisher = LocalEventBusPublisher(eventbus=local_eventbus_instance2)
+
+        await subscriber.connect()
+        await publisher.connect()
+
+        await subscriber.subscribe("test")
+
+        await publisher.publish("test", event)
+
+        self.assertIs(event, received_event)
+
+        await subscriber.unsubscribe()
+        received_event = None
+
+        await publisher.publish("test", event)
+
+        self.assertIs(received_event, None)
+
+
+    async def test_local_client(self):
+        received_event = None
+        event = Event()
+
+        def client_callback(topic_name: str, e: Event):
+            nonlocal received_event
+
+            received_event = e
+
+        client = LocalPubSubClientBuilder()\
+                    .with_default_publisher()\
+                    .with_closure_subscriber(client_callback)\
+                    .build()
+
+        await client.connect()
+
+        await client.subscribe("test")
+
+        await client.publish("test", event)
+
+        self.assertIs(event, received_event)
+
+        await client.unsubscribe()
+        received_event = None
+
+        await client.publish("test", event)
+
+        self.assertIs(received_event, None)
+
+    async def test_mhs(self):
+
+        received_event = 0
+
+        def callback(t: str, e: Event):
+            nonlocal received_event
+
+            received_event += 1
+
+        subscriber = LocalEventBusSubscriber(
+            fallback_event_handler=ClosureEventHandler(callback),
+            eventbus=LocalEventBus()
+        )
+
+        await subscriber.connect()
+
+        await subscriber.subscribe("t1")
+        await subscriber.subscribe("t2", handler=ClosureEventHandler(callback))
+
+        await subscriber.notify("t1", Event())
+
+        self.assertEqual(received_event, 1)
+
+        await subscriber.notify("t2", Event())
+
+        self.assertEqual(received_event, 2)
+
+        await subscriber.unsubscribe()
+
+        await subscriber.notify("t1", Event())
+        await subscriber.notify("t2", Event())
+
+        self.assertEqual(received_event, 2)
+
+    async def test_multi_client(self):
+        local_eventbus_instance1 = AsyncLocalEventBus()  # not singleton
+        local_eventbus_instance2 = AsyncLocalEventBus()  # not singleton
+
+        n_events: int = 0
+
+        def on_event_callback(topic_name: str, e: Event):
+            nonlocal n_events
+
+            n_events += 1
+
+        client1 = LocalPubSubClientBuilder(local_eventbus_instance1)\
+                    .with_default_publisher()\
+                    .with_closure_subscriber(lambda t, e: ...)\
+                    .build()
+
+        client2 = LocalPubSubClientBuilder(local_eventbus_instance2)\
+                    .with_default_publisher()\
+                    .with_closure_subscriber(lambda t, e: ...)\
+                    .build()
+
+        multi_client = EventBusMultiClient([
+            client1,
+            client2
+        ])
+
+        await multi_client.connect()
+
+        await multi_client.subscribe("topic", handler=ClosureEventHandler(on_event_callback))
+
+        await multi_client.publish("topic", Event())
+
+        await multi_client.disconnect()
+
+        self.assertEqual(n_events, 2)
+
+
+
+
+if __name__ == '__main__':
+    unittest.main()