busline 0.3.0__py3-none-any.whl → 0.5.0__py3-none-any.whl

eventbus/topic.py

@@ -1,35 +0,0 @@
-
-
-class Topic:
-    """
-    Topic of generic eventbus.
-
-    :param name: unique name of the topic
-    :param content_type: MIME type which describes content of the topic (e.g. "application/json")
-    :param description: simple topic description
-    :param priority: priority of message in topic related to other topics
-
-    Author: Nicola Ricciardi
-    """
-
-    def __init__(self, name: str, content_type: str | None = None, description: str | None = None, priority: int = 0):
-        self.__name = name
-        self.__description = description
-        self.__content_type = content_type
-        self.__priority = priority
-
-    @property
-    def name(self) -> str:
-        return self.__name
-
-    @property
-    def description(self) -> str | None:
-        return self.__description
-
-    @property
-    def content_type(self) -> str | None:
-        return self.__content_type
-
-    @property
-    def priority(self) -> int:
-        return self.__priority

eventbus_client/eventbus_client.py

@@ -1,99 +0,0 @@
-from uuid import uuid4
-from src.event.event import Event
-from src.eventbus_client.eventbus_connector import EventBusConnector
-from src.eventbus_client.publisher.publisher import Publisher
-from src.eventbus_client.subscriber.event_listener import EventListener
-from src.eventbus_client.subscriber.subscriber import Subscriber
-
-
-class EventBusClient(EventBusConnector):
-    """
-    Eventbus client which should used by components which wouldn't be a publisher/subscriber, but they need them
-
-    Author: Nicola Ricciardi
-    """
-
-    def __init__(self, publisher: Publisher, subscriber: Subscriber, event_listener: EventListener | None = None, client_id: str = str(uuid4())):
-        EventBusConnector.__init__(self, client_id)
-
-        self._id = client_id
-        self.__publisher: Publisher = None
-        self.__subscriber: Subscriber = None
-        self.__event_listener: EventListener = None
-
-        self.publisher = publisher
-        self.subscriber = subscriber
-        self.event_listener = event_listener
-
-    @property
-    def publisher(self) -> Publisher:
-        return self.__publisher
-
-    @publisher.setter
-    def publisher(self, publisher: Publisher):
-        self.__publisher = publisher
-
-    @property
-    def subscriber(self) -> Subscriber:
-        return self.__subscriber
-
-    @subscriber.setter
-    def subscriber(self, subscriber: Subscriber):
-
-        original_on_event = subscriber.on_event
-
-        async def on_event_wrapper(*args, **kwargs):        # wrap on_event method to call self.on_event
-            await original_on_event(*args, **kwargs)
-            await self.on_event(*args, **kwargs)
-
-        subscriber.on_event = on_event_wrapper
-        self.__subscriber = subscriber
-
-    @property
-    def event_listener(self) -> EventListener:
-        return self.__event_listener
-
-    @event_listener.setter
-    def event_listener(self, event_listener: EventListener):
-        self.__event_listener = event_listener
-
-    async def connect(self):
-        c1 = self.__publisher.connect()
-        c2 = self.__subscriber.connect()
-
-        await c1
-        await c2
-
-    async def disconnect(self):
-        d1 = self.__publisher.disconnect()
-        d2 = self.__subscriber.disconnect()
-
-        await d1
-        await d2
-
-    async def publish(self, topic_name: str, event: Event, **kwargs):
-        """
-        Alias of `client.publisher.publish(...)`
-        """
-
-        await self.__publisher.publish(topic_name, event, **kwargs)
-
-    async def subscribe(self, topic_name: str, **kwargs):
-        """
-        Alias of `client.subscriber.subscribe(...)`
-        """
-
-        await self.__subscriber.subscribe(topic_name, **kwargs)
-
-    async def unsubscribe(self, topic_name: str | None = None, **kwargs):
-        """
-        Alias of `client.subscriber.unsubscribe(...)`
-        """
-
-        await self.__subscriber.unsubscribe(topic_name, **kwargs)
-
-    async def on_event(self, topic_name: str, event: Event, **kwargs):
-        if self.__event_listener is not None:
-            await self.__event_listener.on_event(topic_name, event, **kwargs)
-
-

eventbus_client/exceptions.py

@@ -1,4 +0,0 @@
-
-
-class EventBusClientNotConnected(Exception):
-    pass

eventbus_client/local_eventbus_client.py

@@ -1,25 +0,0 @@
-from typing import Callable
-from uuid import uuid4
-
-from src.event.event import Event
-from src.eventbus.async_local_eventbus import AsyncLocalEventBus
-from src.eventbus_client.eventbus_client import EventBusClient
-from src.eventbus_client.publisher.local_eventbus_publisher import LocalEventBusPublisher
-from src.eventbus_client.subscriber.local_eventbus_closure_subscriber import LocalEventBusClosureSubscriber
-
-
-class LocalEventBusClient(EventBusClient):
-
-    def __init__(self, on_event_callback: Callable[[str, Event], None], client_id: str = str(uuid4())):
-
-        eventbus_instance = AsyncLocalEventBus()
-
-        EventBusClient.__init__(
-            self,
-            publisher=LocalEventBusPublisher(eventbus_instance),
-            subscriber=LocalEventBusClosureSubscriber(eventbus_instance, on_event_callback),
-            client_id=client_id
-        )
-
-
-

eventbus_client/publisher/local_eventbus_publisher.py

@@ -1,35 +0,0 @@
-from src.event.event import Event
-from src.eventbus.eventbus import EventBus
-from src.eventbus_client.exceptions import EventBusClientNotConnected
-from src.eventbus_client.publisher.publisher import Publisher
-
-
-class LocalEventBusPublisher(Publisher):
-    """
-    Publisher which works with local eventbus, this class can be initialized and used stand-alone
-
-    Author: Nicola Ricciardi
-    """
-
-    def __init__(self, eventbus_instance: EventBus):
-        Publisher.__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_publish(self, topic_name: str, event: Event, raise_if_not_connected: bool = False, **kwargs):
-
-        if raise_if_not_connected and not self._connected:
-            raise EventBusClientNotConnected()
-        else:
-            await self.connect()
-
-        self.on_publishing(topic_name, event)
-        await self._eventbus.put_event(topic_name, event)
-        self.on_published(topic_name, event)

eventbus_client/publisher/publisher.py

@@ -1,59 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,40 +0,0 @@
-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

@@ -1,93 +0,0 @@
-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:
-        """