busline 0.3.0__py3-none-any.whl

eventbus_client/publisher/publisher.py

@@ -0,0 +1,59 @@
+import logging
+from abc import ABC, abstractmethod
+from uuid import uuid4
+
+from src.event.event import Event
+from src.eventbus_client.eventbus_connector import EventBusConnector
+
+
+class Publisher(EventBusConnector, ABC):
+    """
+    Abstract class which can be implemented by your components which must be able to publish on eventbus
+
+    Author: Nicola Ricciardi
+    """
+
+    def __init__(self, publisher_id: str = str(uuid4())):
+        EventBusConnector.__init__(self, publisher_id)
+
+    @abstractmethod
+    async def _internal_publish(self, topic_name: str, event: Event, **kwargs):
+        """
+        Actual publish on topic the event
+
+        :param topic_name:
+        :param event:
+        :return:
+        """
+
+    async def publish(self, topic_name: str, event: Event, **kwargs):
+        """
+        Publish on topic the event
+
+        :param topic_name:
+        :param event:
+        :return:
+        """
+
+        logging.debug(f"{self._id} publishing on {topic_name}: {event}")
+        self.on_publishing(topic_name, event)
+        await self._internal_publish(topic_name, event, **kwargs)
+        self.on_published(topic_name, event)
+
+    def on_publishing(self, topic_name: str, event: Event):
+        """
+        Callback called on publishing start
+
+        :param topic_name:
+        :param event:
+        :return:
+        """
+
+    def on_published(self, topic_name: str, event: Event):
+        """
+        Callback called on publishing end
+
+        :param topic_name:
+        :param event:
+        :return:
+        """

eventbus_client/subscriber/closure_event_listener.py

@@ -0,0 +1,19 @@
+from typing import Callable
+from src.event.event import Event
+from src.eventbus_client.subscriber.event_listener import EventListener
+
+
+class ClosureEventListener(EventListener):
+    """
+    Abstract event listener which use a pre-defined callback as `on_event`
+
+    Author: Nicola Ricciardi
+    """
+
+    def __init__(self, on_event_callback: Callable[[str, Event], None]):
+        EventListener.__init__(self)
+
+        self.__on_event_callback = on_event_callback
+
+    async def on_event(self, topic_name: str, event: Event, **kwargs):
+        self.__on_event_callback(topic_name, event, **kwargs)

eventbus_client/subscriber/event_listener.py

@@ -0,0 +1,15 @@
+from abc import ABC, abstractmethod
+from src.event.event import Event
+
+
+class EventListener(ABC):
+
+    @abstractmethod
+    async def on_event(self, topic_name: str, event: Event, **kwargs):
+        """
+        Callback called when new event arrives
+
+        :param topic_name:
+        :param event:
+        :return:
+        """

eventbus_client/subscriber/local_eventbus_closure_subscriber.py

@@ -0,0 +1,17 @@
+from typing import Callable
+from src.event.event import Event
+from src.eventbus.eventbus import EventBus
+from src.eventbus_client.subscriber.closure_event_listener import ClosureEventListener
+from src.eventbus_client.subscriber.local_eventbus_subscriber import LocalEventBusSubscriber
+
+
+class LocalEventBusClosureSubscriber(LocalEventBusSubscriber, ClosureEventListener):
+    """
+    Subscriber which works with local eventbus, this class can be initialized and used stand-alone
+
+    Author: Nicola Ricciardi
+    """
+
+    def __init__(self, eventbus_instance: EventBus, on_event_callback: Callable[[str, Event], None]):
+        LocalEventBusSubscriber.__init__(self, eventbus_instance)
+        ClosureEventListener.__init__(self, on_event_callback)

eventbus_client/subscriber/local_eventbus_subscriber.py

@@ -0,0 +1,40 @@
+from abc import ABC
+from src.eventbus.eventbus import EventBus
+from src.eventbus_client.exceptions import EventBusClientNotConnected
+from src.eventbus_client.subscriber.subscriber import Subscriber
+
+
+class LocalEventBusSubscriber(Subscriber, ABC):
+    """
+    Abstract subscriber which works with local eventbus without implementing `on_event` method
+
+    Author: Nicola Ricciardi
+    """
+
+    def __init__(self, eventbus_instance: EventBus):
+        Subscriber.__init__(self)
+
+        self._eventbus = eventbus_instance
+        self._connected = False
+
+    async def connect(self):
+        self._connected = True
+
+    async def disconnect(self):
+        self._connected = False
+
+    async def _internal_subscribe(self, topic_name: str, raise_if_not_connected: bool = False, **kwargs):
+        if raise_if_not_connected and not self._connected:
+            raise EventBusClientNotConnected()
+        else:
+            await self.connect()
+
+        self._eventbus.add_subscriber(topic_name, self)
+
+    async def _internal_unsubscribe(self, topic_name: str | None = None, raise_if_not_connected: bool = False, **kwargs):
+        if raise_if_not_connected and not self._connected:
+            raise EventBusClientNotConnected()
+        else:
+            await self.connect()
+
+        self._eventbus.remove_subscriber(self, topic_name)

eventbus_client/subscriber/subscriber.py

@@ -0,0 +1,93 @@
+from abc import ABC, abstractmethod
+from uuid import uuid4
+
+from src.event.event import Event
+from src.eventbus_client.eventbus_connector import EventBusConnector
+from src.eventbus_client.subscriber.event_listener import EventListener
+
+
+class Subscriber(EventBusConnector, EventListener, ABC):
+    """
+    Abstract class which can be implemented by your components which must be able to subscribe on eventbus
+
+    Author: Nicola Ricciardi
+    """
+
+    def __init__(self, subscriber_id: str = str(uuid4())):
+        EventBusConnector.__init__(self, subscriber_id)
+        EventListener.__init__(self)
+
+
+    @abstractmethod
+    async def _internal_subscribe(self, topic_name: str, **kwargs):
+        """
+        Actual subscribe to topic
+
+        :param topic_name:
+        :return:
+        """
+
+    @abstractmethod
+    async def _internal_unsubscribe(self, topic_name: str | None = None, **kwargs):
+        """
+        Actual unsubscribe to topic
+
+        :param topic_name:
+        :return:
+        """
+
+    async def subscribe(self, topic_name: str, **kwargs):
+        """
+        Subscribe to topic
+
+        :param topic_name:
+        :return:
+        """
+
+        self.on_subscribing(topic_name)
+        await self._internal_subscribe(topic_name, **kwargs)
+        self.on_subscribed(topic_name)
+
+    async def unsubscribe(self, topic_name: str | None = None, **kwargs):
+        """
+        Unsubscribe to topic
+
+        :param topic_name:
+        :return:
+        """
+
+        self.on_unsubscribing(topic_name)
+        await self._internal_unsubscribe(topic_name, **kwargs)
+        self.on_unsubscribed(topic_name)
+
+    def on_subscribing(self, topic_name: str):
+        """
+        Callback called on subscribing
+
+        :param topic_name:
+        :return:
+        """
+
+    def on_subscribed(self, topic_name: str):
+        """
+        Callback called on subscribed
+
+        :param topic_name:
+        :return:
+        """
+
+    def on_unsubscribing(self, topic_name: str):
+        """
+        Callback called on unsubscribing
+
+        :param topic_name:
+        :return:
+        """
+
+    def on_unsubscribed(self, topic_name: str):
+        """
+        Callback called on unsubscribed
+
+        :param topic_name:
+        :return:
+        """