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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fdc_shared_kernel
-Version: 0.0.24
+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
@@ -31,6 +31,7 @@ Requires-Dist: boto3==1.34.148
 Requires-Dist: azure-keyvault-secrets==4.8.0
 Requires-Dist: azure-identity==1.17.1
 Requires-Dist: twine==5.1.1
+Requires-Dist: httpx==0.27.0
 
 # FDC Shared Kernel
 

{fdc_shared_kernel-0.0.24 → 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.24
+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
@@ -31,6 +31,7 @@ Requires-Dist: boto3==1.34.148
 Requires-Dist: azure-keyvault-secrets==4.8.0
 Requires-Dist: azure-identity==1.17.1
 Requires-Dist: twine==5.1.1
+Requires-Dist: httpx==0.27.0
 
 # FDC Shared Kernel
 

{fdc_shared_kernel-0.0.24 → fdc_shared_kernel-0.0.26}/fdc_shared_kernel.egg-info/SOURCES.txt

@@ -30,6 +30,7 @@ shared_kernel/interfaces/http.py
 shared_kernel/interfaces/keyvault.py
 shared_kernel/logger/__init__.py
 shared_kernel/messaging/__init__.py
+shared_kernel/messaging/http_databus.py
 shared_kernel/messaging/nats_databus.py
 shared_kernel/metrics/__init__.py
 shared_kernel/metrics/status_tracker.py

fdc_shared_kernel-0.0.24/requirements.txt → fdc_shared_kernel-0.0.26/fdc_shared_kernel.egg-info/requires.txt

@@ -20,4 +20,5 @@ boto3==1.34.148
 boto3==1.34.148
 azure-keyvault-secrets==4.8.0
 azure-identity==1.17.1
-twine==5.1.1
+twine==5.1.1
+httpx==0.27.0

{fdc_shared_kernel-0.0.24 → 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.24"
+version = "0.0.26"
 requires-python = ">=3.7"
 readme = "README_pypi.md"
 description = "Shared library for microservice"

fdc_shared_kernel-0.0.24/fdc_shared_kernel.egg-info/requires.txt → fdc_shared_kernel-0.0.26/requirements.txt

@@ -21,3 +21,4 @@ boto3==1.34.148
 azure-keyvault-secrets==4.8.0
 azure-identity==1.17.1
 twine==5.1.1
+httpx==0.27.0

{fdc_shared_kernel-0.0.24 → fdc_shared_kernel-0.0.26}/shared_kernel/http/__init__.py

@@ -5,7 +5,7 @@ from shared_kernel.interfaces.http import HttpApiClient
 
 class HttpClient:
     @staticmethod
-    def create_key_vault(client_type: str = "requests") -> HttpApiClient:
+    def create_client(client_type: str = "requests") -> HttpApiClient:
         if client_type == 'requests':
             return RequestsHttpClient()
         elif client_type == 'httpx':

fdc_shared_kernel-0.0.26/shared_kernel/interfaces/databus.py

@@ -0,0 +1,112 @@
+from abc import ABC, abstractmethod
+from typing import Any, Callable
+
+
+class DataBus(ABC):
+    """
+    An abstract base class for a DataBus interface that handles both asynchronous and synchronous messaging.
+
+    Methods
+    -------
+    __init__() -> None:
+        Initializes the DataBus instance.
+
+    make_connection():
+        Connects to the DataBus server.
+
+    close_connection():
+        Closes the connection to the DataBus server.
+
+    publish_event(event_name: str, event_payload: dict):
+        Publishes an asynchronous message to a DataBus event_name.
+
+    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(event_name: str, callback: Callable[[Any], None]):
+        Subscribes to a DataBus event_name and processes messages synchronously.
+
+    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.
+    """
+
+    @abstractmethod
+    def __init__(self) -> None:
+        """
+        Initializes the DataBus instance.
+        """
+        pass
+
+    @abstractmethod
+    def make_connection(self):
+        """
+        Connect to the DataBus server.
+        """
+        pass
+
+    @abstractmethod
+    def close_connection(self):
+        """
+        Close the connection to the DataBus server.
+        """
+        pass
+
+    @abstractmethod
+    def publish_event(self, event_name: str, event_payload: dict):
+        """
+        Publish an asynchronous message to a DataBus event_name.
+
+        Parameters:
+        - 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, event_name: str, event_payload: dict) -> Any:
+        """
+        Send a synchronous request/message to a DataBus event name and receive a response.
+
+        Parameters:
+        - event_name (str): The event name to send the message to.
+        - event_payload (dict): The message to be sent.
+
+        Returns:
+        - Any: The response received from the server.
+        """
+        pass
+
+    @abstractmethod
+    def subscribe_sync_event(self, event_name: str, callback: Callable[[Any], None]):
+        """
+        Subscribe to a DataBus event name and process messages synchronously.
+
+        Parameters:
+        - 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, event_name: str, callback: Callable[[Any], None]):
+        """
+        Subscribe to a DataBus event name and process messages asynchronously.
+
+        Parameters:
+        - event_name (str): The event name to subscribe to.
+        - callback (Callable[[Any], None]): A callback function to handle received messages.
+        """
+        pass
+
+    @abstractmethod
+    def delete_message(self, message_id: str):
+        """
+        Delete a message from the DataBus.
+
+        Parameters:
+        - message_id (str): The ID or receipt handle of the message to delete.
+        """
+        pass

fdc_shared_kernel-0.0.26/shared_kernel/messaging/__init__.py

@@ -0,0 +1,14 @@
+from shared_kernel.messaging.nats_databus import NATSDataBus
+from shared_kernel.messaging.http_databus import HTTPDataBus
+from shared_kernel.interfaces import DataBus
+
+
+class DataBus:
+    data_bus_classes = {"NATS": NATSDataBus, "HTTP": HTTPDataBus}
+
+    @staticmethod
+    def create_data_bus(bus_type: str, config: dict) -> DataBus:
+        data_bus_class = DataBus.data_bus_classes.get(bus_type)
+        if data_bus_class is None:
+            raise ValueError(f"Unknown data bus type: {bus_type}")
+        return data_bus_class(config)

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.24 → fdc_shared_kernel-0.0.26}/shared_kernel/messaging/nats_databus.py

@@ -2,16 +2,15 @@ import json
 import logging
 from nats.aio.client import Client as NATS
 from nats.js.api import StreamConfig, ConsumerConfig, DeliverPolicy
-from typing import Callable, Any, List, Union
+from typing import Callable, Any, List, Union, Dict
 from shared_kernel.interfaces import DataBus
 
-
 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
@@ -21,31 +20,38 @@ class NATSDataBus(DataBus):
             cls._instance = super(NATSDataBus, cls).__new__(cls)
         return cls._instance
 
-    def __init__(self, servers: str = None, user: str = None, password: str = None):
+    def __init__(self, config: Dict = None):
         """
-        Initialize the NATSInterface.
+        Initialize the NATSDataBus.
 
         Args:
-            servers (str): A string containing the NATS server URLs.
+            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 = servers
-            self.user = user
-            self.password = password
+            self.servers = config.get('servers')
+            self.user = config.get('user')
+            self.password = config.get('password')
             self.connected = False
             self.js = None  # JetStream context
             self.initialized = True
+            self.stream_name = config.get('stream_name', '')
+            self.event_names = config.get('event_names', [])
+
+            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
 
@@ -53,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
@@ -76,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.
 
@@ -117,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
@@ -147,16 +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.24 → fdc_shared_kernel-0.0.26}/shared_kernel/security/key_vault/__init__.py

@@ -4,11 +4,12 @@ from shared_kernel.security.key_vault.azure_keyvault import AzureKeyVault
 
 
 class KeyVaultManager:
+
+    keyvault_classes = {"AZURE": AzureKeyVault, "AWS": AWSSecretsManager}
+
     @staticmethod
-    def create_key_vault(vault_type: str, config: dict) -> KeyVaultInterface:
-        if vault_type == 'AZURE':
-            return AzureKeyVault(config)
-        elif vault_type == 'AWS':
-            return AWSSecretsManager(config)
-        else:
+    def create_data_bus(vault_type: str, config: dict) -> KeyVaultInterface:
+        keyvault_class = KeyVaultManager.keyvault_classes.get(vault_type)
+        if keyvault_class is None:
             raise ValueError(f"Unknown vault type: {vault_type}")
+        return keyvault_class(config)

fdc_shared_kernel-0.0.24/shared_kernel/interfaces/databus.py

@@ -1,99 +0,0 @@
-from abc import ABC, abstractmethod
-from typing import Any, Callable
-
-
-class DataBus(ABC):
-    """
-    An abstract base class for a DataBus interface that handles both asynchronous and synchronous messaging.
-
-    Methods
-    -------
-    __init__() -> None:
-        Initializes the DataBus instance.
-
-    make_connection():
-        Connects to the DataBus server.
-
-    close_connection():
-        Closes the connection to the DataBus server.
-
-    publish_event(topic: str, event_payload: dict):
-        Publishes an asynchronous message to a DataBus topic.
-
-    request_event(topic: str, event_payload: dict) -> Any:
-        Sends a synchronous request/message to a DataBus topic and receives a response.
-
-    subscribe_sync_event(topic: str, callback: Callable[[Any], None]):
-        Subscribes to a DataBus topic and processes messages synchronously.
-
-    subscribe_async_event(topic: str, callback: Callable[[Any], None]):
-        Subscribes to a DataBus topic and processes messages asynchronously.
-    """
-
-    @abstractmethod
-    def __init__(self) -> None:
-        """
-        Initializes the DataBus instance.
-        """
-        pass
-
-    @abstractmethod
-    def make_connection(self):
-        """
-        Connect to the DataBus server.
-        """
-        pass
-
-    @abstractmethod
-    def close_connection(self):
-        """
-        Close the connection to the DataBus server.
-        """
-        pass
-
-    @abstractmethod
-    def publish_event(self, topic: str, event_payload: dict):
-        """
-        Publish an asynchronous message to a DataBus topic.
-
-        Parameters:
-        - topic (str): The topic 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:
-        """
-        Send a synchronous request/message to a DataBus topic and receive a response.
-
-        Parameters:
-        - topic (str): The topic to send the message to.
-        - event_payload (dict): The message to be sent.
-
-        Returns:
-        - Any: The response received from the server.
-        """
-        pass
-
-    @abstractmethod
-    def subscribe_sync_event(self, topic: str, callback: Callable[[Any], None]):
-        """
-        Subscribe to a DataBus topic and process messages synchronously.
-
-        Parameters:
-        - topic (str): The topic 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]):
-        """
-        Subscribe to a DataBus topic and process messages asynchronously.
-
-        Parameters:
-        - topic (str): The topic to subscribe to.
-        - callback (Callable[[Any], None]): A callback function to handle received messages.
-        """
-        pass

fdc_shared_kernel-0.0.24/shared_kernel/messaging/__init__.py

@@ -1 +0,0 @@
-from shared_kernel.messaging.nats_databus import * # noqa