fdc-shared-kernel 0.0.25__tar.gz → 0.0.26__tar.gz

{fdc_shared_kernel-0.0.25 → fdc_shared_kernel-0.0.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fdc_shared_kernel
-Version: 0.0.25
+Version: 0.0.26
 Summary: Shared library for microservice
 Author-email: Shikhil S <shikhil.s@dbizsolution.com>, Ahammed Akdham N <ahammedakdham.n@dbizsolution.com>
 Classifier: Programming Language :: Python :: 3

{fdc_shared_kernel-0.0.25 → fdc_shared_kernel-0.0.26}/fdc_shared_kernel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fdc_shared_kernel
-Version: 0.0.25
+Version: 0.0.26
 Summary: Shared library for microservice
 Author-email: Shikhil S <shikhil.s@dbizsolution.com>, Ahammed Akdham N <ahammedakdham.n@dbizsolution.com>
 Classifier: Programming Language :: Python :: 3

{fdc_shared_kernel-0.0.25 → fdc_shared_kernel-0.0.26}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fdc_shared_kernel"
-version = "0.0.25"
+version = "0.0.26"
 requires-python = ">=3.7"
 readme = "README_pypi.md"
 description = "Shared library for microservice"

{fdc_shared_kernel-0.0.25 → fdc_shared_kernel-0.0.26}/shared_kernel/interfaces/databus.py

@@ -17,17 +17,17 @@ class DataBus(ABC):
     close_connection():
         Closes the connection to the DataBus server.
 
-    publish_event(topic: str, event_payload: dict):
-        Publishes an asynchronous message to a DataBus topic.
+    publish_event(event_name: str, event_payload: dict):
+        Publishes an asynchronous message to a DataBus event_name.
 
-    request_event(topic: str, event_payload: dict) -> Any:
-        Sends a synchronous request/message to a DataBus topic and receives a response.
+    request_event(event_name: str, event_payload: dict) -> Any:
+        Sends a synchronous request/message to a DataBus event_name and receives a response.
 
-    subscribe_sync_event(topic: str, callback: Callable[[Any], None]):
-        Subscribes to a DataBus topic and processes messages synchronously.
+    subscribe_sync_event(event_name: str, callback: Callable[[Any], None]):
+        Subscribes to a DataBus event_name and processes messages synchronously.
 
-    subscribe_async_event(topic: str, callback: Callable[[Any], None]):
-        Subscribes to a DataBus topic and processes messages asynchronously.
+    subscribe_async_event(event_name: str, callback: Callable[[Any], None]):
+        Subscribes to a DataBus event_name and processes messages asynchronously.
 
     delete_message(message_id: str):
         Deletes a message from the DataBus.
@@ -55,23 +55,23 @@ class DataBus(ABC):
         pass
 
     @abstractmethod
-    def publish_event(self, topic: str, event_payload: dict):
+    def publish_event(self, event_name: str, event_payload: dict):
         """
-        Publish an asynchronous message to a DataBus topic.
+        Publish an asynchronous message to a DataBus event_name.
 
         Parameters:
-        - topic (str): The topic to publish the message to.
+        - event_name (str): The event name to publish the message to.
         - event_payload (dict): The message to be published.
         """
         pass
 
     @abstractmethod
-    def request_event(self, topic: str, event_payload: dict) -> Any:
+    def request_event(self, event_name: str, event_payload: dict) -> Any:
         """
-        Send a synchronous request/message to a DataBus topic and receive a response.
+        Send a synchronous request/message to a DataBus event name and receive a response.
 
         Parameters:
-        - topic (str): The topic to send the message to.
+        - event_name (str): The event name to send the message to.
         - event_payload (dict): The message to be sent.
 
         Returns:
@@ -80,23 +80,23 @@ class DataBus(ABC):
         pass
 
     @abstractmethod
-    def subscribe_sync_event(self, topic: str, callback: Callable[[Any], None]):
+    def subscribe_sync_event(self, event_name: str, callback: Callable[[Any], None]):
         """
-        Subscribe to a DataBus topic and process messages synchronously.
+        Subscribe to a DataBus event name and process messages synchronously.
 
         Parameters:
-        - topic (str): The topic to subscribe to.
+        - event_name (str): The event name to subscribe to.
         - callback (Callable[[Any], None]): A callback function to handle received messages.
         """
         pass
 
     @abstractmethod
-    def subscribe_async_event(self, topic: str, callback: Callable[[Any], None]):
+    def subscribe_async_event(self, event_name: str, callback: Callable[[Any], None]):
         """
-        Subscribe to a DataBus topic and process messages asynchronously.
+        Subscribe to a DataBus event name and process messages asynchronously.
 
         Parameters:
-        - topic (str): The topic to subscribe to.
+        - event_name (str): The event name to subscribe to.
         - callback (Callable[[Any], None]): A callback function to handle received messages.
         """
         pass

{fdc_shared_kernel-0.0.25 → fdc_shared_kernel-0.0.26}/shared_kernel/messaging/__init__.py

@@ -1,10 +1,10 @@
 from shared_kernel.messaging.nats_databus import NATSDataBus
-from shared_kernel.messaging.http_databus import HTTPDatabus
+from shared_kernel.messaging.http_databus import HTTPDataBus
 from shared_kernel.interfaces import DataBus
 
 
 class DataBus:
-    data_bus_classes = {"NATS": NATSDataBus, "HTTP": HTTPDatabus}
+    data_bus_classes = {"NATS": NATSDataBus, "HTTP": HTTPDataBus}
 
     @staticmethod
     def create_data_bus(bus_type: str, config: dict) -> DataBus:

fdc_shared_kernel-0.0.26/shared_kernel/messaging/http_databus.py

@@ -0,0 +1,125 @@
+import asyncio
+import logging
+from typing import Callable, Any, Dict
+from shared_kernel.interfaces import DataBus
+from concurrent.futures import ThreadPoolExecutor
+from shared_kernel.http import HttpClient
+
+logging.getLogger().setLevel(logging.INFO)
+
+
+class HTTPDataBus(DataBus):
+    """
+    A class to handle HTTP-based event operations, including EventBridge and SQS.
+    """
+
+    _instance = None
+
+    def __new__(cls, *args, **kwargs):
+        if cls._instance is None:
+            cls._instance = super(HTTPDataBus, cls).__new__(cls)
+        return cls._instance
+
+    def __init__(self, config: Dict = None):
+        """
+        Initialize the HTTPDataBus.
+
+        Args:
+            config (Dict): A dictionary containing the HTTP client configuration.
+        """
+        if not hasattr(self, "initialized"):  # Prevent reinitialization
+            super().__init__()
+            self.http_client = HttpClient().create_client()
+            self.initialized = True
+
+    async def publish_event(self, event_name: str, event_payload: dict):
+        """
+        Send an event payload to multiple HTTP endpoints and return the responses.
+
+        Args:
+            event_name (str): The URLs to invoke the HTTP endpoints.
+            event_payload (dict): The payload containing all necessary information for the HTTP requests.
+
+        Returns:
+            None
+        """
+        with ThreadPoolExecutor(max_workers=5) as executor:
+            futures = [executor.submit(self.http_client.post, url=url, json=event_payload) for url in event_name]
+            for future in futures:
+                future.result()
+
+    def subscribe_async_event(self, event_name: str, callback: Callable[[Any], None]):
+        """
+        Subscribe to asynchronous events and invoke the provided callback upon receiving an event.
+
+        Args:
+            event_name (str): The event name or URL to subscribe to.
+            callback (Callable[[Any], None]): The callback function to invoke with the event data.
+
+        Returns:
+            asyncio.Task: The task handling the asynchronous event subscription.
+        """
+        return asyncio.create_task(callback(event_name))
+
+    def request_event(self, event_name: str, event_payload: dict) -> Any:
+        """
+        Send an event payload to an HTTP endpoint and return the response.
+
+        Args:
+            event_name (str): The URL to invoke the HTTP endpoint.
+            event_payload (dict): The payload containing all necessary information for the HTTP request.
+
+        Returns:
+            Any: The response from the HTTP endpoint.
+        """
+        response = self.http_client.post(url=event_name, json=event_payload)
+        return response
+
+    def subscribe_sync_event(self, event_name: str, callback: Callable[[Any], None]):
+        """
+        Subscribe to synchronous events and invoke the provided callback upon receiving an event.
+
+        Args:
+            event_name (str): The event name or URL to subscribe to.
+            callback (Callable[[Any], None]): The callback function to invoke with the event data.
+
+        Returns:
+            Any: The result of the callback function.
+        """
+        return callback(event_name)
+
+    def delete_message(self, receipt_handle: str):
+        """
+        Placeholder method for deleting a message.
+
+        Args:
+            receipt_handle (str): The receipt handle of the message to be deleted.
+
+        Returns:
+            None
+        """
+        pass
+
+    def make_connection(self, receipt_handle: str):
+        """
+        Placeholder method for establishing a connection.
+
+        Args:
+            receipt_handle (str): The receipt handle related to the connection.
+
+        Returns:
+            None
+        """
+        pass
+
+    def close_connection(self, receipt_handle: str):
+        """
+        Placeholder method for closing a connection.
+
+        Args:
+            receipt_handle (str): The receipt handle related to the connection.
+
+        Returns:
+            None
+        """
+        pass

{fdc_shared_kernel-0.0.25 → fdc_shared_kernel-0.0.26}/shared_kernel/messaging/nats_databus.py

@@ -10,7 +10,7 @@ logging.getLogger().setLevel(logging.INFO)
 
 class NATSDataBus(DataBus):
     """
-    A NATS Interface class to handle both standard NATS and JetStream operations.
+    A NATS interface class to handle both standard NATS and JetStream operations.
     """
 
     _instance = None
@@ -22,12 +22,12 @@ class NATSDataBus(DataBus):
 
     def __init__(self, config: Dict = None):
         """
-        Initialize the NATSInterface.
+        Initialize the NATSDataBus.
 
         Args:
-            config (Dict): A Dict containing the NATS config.
+            config (Dict): A dictionary containing the NATS configuration.
         """
-        if not hasattr(self, "initialized"):  # to prevent reinitialization
+        if not hasattr(self, "initialized"):  # Prevent reinitialization
             super().__init__()
             self.nc = NATS()
             self.servers = config.get('servers')
@@ -37,20 +37,21 @@ class NATSDataBus(DataBus):
             self.js = None  # JetStream context
             self.initialized = True
             self.stream_name = config.get('stream_name', '')
-            self.topics = config.get('topics', [])
+            self.event_names = config.get('event_names', [])
 
-            if self.stream_name:
-                if self.topics:
-                    self.create_stream(self.stream_name, self.topics)
+            if self.stream_name and self.event_names:
+                self.create_stream(self.stream_name, self.event_names)
 
     async def make_connection(self):
         """
         Connect to the NATS server.
         """
         if not self.connected:
-            await self.nc.connect(servers=self.servers,
-                                  user=self.user,
-                                  password=self.password)
+            await self.nc.connect(
+                servers=self.servers,
+                user=self.user,
+                password=self.password
+            )
             self.js = self.nc.jetstream(timeout=10)
             self.connected = True
 
@@ -58,19 +59,20 @@ class NATSDataBus(DataBus):
         """
         Close the connection to the NATS server.
         """
-        try:
-            if self.connected:
+        if self.connected:
+            try:
                 await self.nc.close()
                 self.connected = False
-        except Exception as e:
-            raise e
+            except Exception as e:
+                raise e
 
-    async def create_stream(self, stream_name: str, topics: List[Any]):
+    async def create_stream(self, stream_name: str, event_names: List[Any]):
         """
-        Create a stream for topics to persist the messages
+        Create a stream for event names to persist the messages.
 
         Args:
-            topics (List): The messages in this topic with be persisted.
+            stream_name (str): The name of the stream.
+            event_names (List[Any]): The subjects whose messages will be persisted.
         """
         try:
             self.stream_name = stream_name
@@ -81,40 +83,41 @@ class NATSDataBus(DataBus):
             # Stream does not exist, so create it
             stream_config = StreamConfig(
                 name=stream_name,
-                subjects=topics,
-                max_age=600,  # retain messages for 10 mins
+                subjects=event_names,
+                max_age=600  # Retain messages for 10 minutes
             )
             await self.js.add_stream(stream_config)
-            logging.info(f"Stream created :: {stream_name}")
+            logging.info(f"Stream '{stream_name}' created.")
 
     async def publish_event(
-            self, topic: str, event_payload: dict
+            self, event_name: str, event_payload: dict
     ) -> Union[bool, Exception]:
         """
         Publish a message to a JetStream subject.
 
         Args:
-            topic (str): The topic to publish the message to.
+            event_name (str): The subject to publish the message to.
             event_payload (dict): The message to be published.
 
         Returns:
             bool: True if the event was published successfully.
         """
         ack = await self.js.publish(
-            topic, json.dumps(event_payload).encode("utf-8")
+            event_name, json.dumps(event_payload).encode("utf-8")
         )
         logging.info(
-            f"Published event '{event_payload.get('event_name')}' to topic '{topic}', ack: {ack}"
+            f"Published event '{event_payload.get('event_name')}' to subject '{event_name}', ack: {ack}"
         )
+        return True
 
     async def request_event(
-            self, topic: str, event_payload: str, timeout: float = 10.0
+            self, event_name: str, event_payload: dict, timeout: float = 10.0
     ) -> Union[dict, Exception]:
         """
         Send a request and wait for a response.
 
         Args:
-            topic (str): The topic to publish the message to.
+            event_name (str): The subject to publish the message to.
             event_payload (dict): The message to be published.
             timeout (float): The timeout for the request.
 
@@ -122,19 +125,20 @@ class NATSDataBus(DataBus):
             dict: The response message.
         """
         response = await self.nc.request(
-            topic, json.dumps(event_payload).encode("utf-8"), timeout=timeout
+            event_name, json.dumps(event_payload).encode("utf-8"), timeout=timeout
         )
         return json.loads(response.data.decode("utf-8"))
 
     async def subscribe_async_event(
-            self, topic: str, callback: Callable[[Any], None], durable_name: str
+            self, event_name: str, callback: Callable[[Any], None], durable_name: str
     ):
         """
         Subscribe to a JetStream subject with a durable consumer and process messages asynchronously.
 
         Args:
-            topic: The topic to subscribe to.
-            callback: A callback function to handle received messages.
+            event_name (str): The subject to subscribe to.
+            callback (Callable[[Any], None]): A callback function to handle received messages.
+            durable_name (str): The name of the durable consumer.
         """
         try:
             # Check if the consumer already exists
@@ -152,21 +156,22 @@ class NATSDataBus(DataBus):
             await self.js.add_consumer(stream=self.stream_name, config=self.consumer_config)
             logging.info(f"Consumer '{durable_name}' created.")
 
-        await self.js.subscribe_bind(stream=self.stream_name, cb=callback, config=self.consumer_config,
-                                     consumer=durable_name)
-        logging.info(f"Subscribed to async event on topic '{topic}'")
+        await self.js.subscribe_bind(
+            stream=self.stream_name, cb=callback, config=self.consumer_config,
+            consumer=durable_name
+        )
+        logging.info(f"Subscribed to async event on subject '{event_name}'")
 
-    async def subscribe_sync_event(self, topic: str, callback: Callable[[Any], None]):
+    async def subscribe_sync_event(self, event_name: str, callback: Callable[[Any], None]):
         """
-        Subscribe to a NATS subject and return a response after processing the message.
+        Subscribe to a NATS subject and process the message synchronously.
 
         Args:
-            topic: The topic to subscribe to.
-            callback: A callback function to handle received messages.
+            event_name (str): The subject to subscribe to.
+            callback (Callable[[Any], None]): A callback function to handle received messages.
         """
-        await self.nc.subscribe(topic, cb=callback)
-        logging.info(f"Subscribed to sync event on topic '{topic}'")
+        await self.nc.subscribe(event_name, cb=callback)
+        logging.info(f"Subscribed to sync event on subject '{event_name}'")
 
     def delete_message(self, receipt_handle: str):
         pass
-

fdc_shared_kernel-0.0.25/shared_kernel/messaging/http_databus.py

@@ -1,82 +0,0 @@
-import asyncio
-import logging
-from typing import Callable, Any, Dict
-from shared_kernel.interfaces import DataBus
-from concurrent.futures import ThreadPoolExecutor
-from shared_kernel.http import HttpClient
-
-logging.getLogger().setLevel(logging.INFO)
-
-
-class HTTPDatabus(DataBus):
-    """
-    A class to handle EventBridge and SQS operations.
-    """
-
-    _instance = None
-
-    def __new__(cls, *args, **kwargs):
-        if cls._instance is None:
-            cls._instance = super(HTTPDatabus, cls).__new__(cls)
-        return cls._instance
-
-    def __init__(self, config: Dict = None):
-        """
-        Initialize the NATSInterface.
-
-        Args:
-            config (Dict): A Dict containing the NATS config.
-        """
-        if not hasattr(self, "initialized"):  # to prevent reinitialization
-            super().__init__()
-            self.http_client = HttpClient().create_client()
-
-    async def publish_event(self, topic: str, event_payload: dict):
-        """
-        Sends an event payload to an HTTP endpoint and returns the response.
-
-        :param topic: The URL for invoking the HTTP endpoint.
-        :param event_payload: The payload containing all necessary information for invoking the HTTP endpoint.
-        :return: The response from the HTTP endpoint.
-        """
-
-        with ThreadPoolExecutor(max_workers=5) as executor:
-            futures = [executor.submit(self.http_client.post, url=url, json=event_payload) for url in topic]
-            for future in futures:
-                future.result()
-
-    def subscribe_async_event(self, topic: str, callback: Callable[[Any], None]):
-        """
-        Subscribes to synchronous events and invokes the provided callback upon receiving an event.
-
-        :param callback: The callback function to invoke with the event data.
-        """
-        return asyncio.create_task(callback(topic))
-
-    def request_event(self, topic: str, event_payload: dict) -> Any:
-        """
-        Sends an event payload to an HTTP endpoint and returns the response.
-
-        :param topic: The URL for invoking the HTTP endpoint.
-        :param event_payload: The payload containing all necessary information for invoking the HTTP endpoint.
-        :return: The response from the HTTP endpoint.
-        """
-        response = self.http_client.post(url=topic, json=event_payload)
-        return response
-
-    def subscribe_sync_event(self, topic: str, callback: Callable[[Any], None]):
-        """
-        Subscribes to synchronous events and invokes the provided callback upon receiving an event.
-
-        :param callback: The callback function to invoke with the event data.
-        """
-        return callback(topic)
-
-    def delete_message(self, receipt_handle: str):
-        pass
-
-    def make_connection(self, receipt_handle: str):
-        pass
-
-    def close_connection(self, receipt_handle: str):
-        pass