fdc-shared-kernel 0.0.3__py3-none-any.whl

fdc_shared_kernel-0.0.3.dist-info/METADATA

@@ -0,0 +1,159 @@
+Metadata-Version: 2.1
+Name: fdc_shared_kernel
+Version: 0.0.3
+Summary: Shared library for microservice
+Author-email: Shikhil S <shikhil.s@dbizsolution.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: alembic ==1.13.2
+Requires-Dist: asynctest ==0.13.0
+Requires-Dist: build ==1.2.1
+Requires-Dist: colorama ==0.4.6
+Requires-Dist: greenlet ==3.0.3
+Requires-Dist: iniconfig ==2.0.0
+Requires-Dist: Mako ==1.3.5
+Requires-Dist: MarkupSafe ==2.1.5
+Requires-Dist: nats-py ==2.8.0
+Requires-Dist: packaging ==24.1
+Requires-Dist: pluggy ==1.5.0
+Requires-Dist: psycopg2-binary ==2.9.9
+Requires-Dist: pytest ==8.2.2
+Requires-Dist: pytest-asyncio ==0.23.8
+Requires-Dist: python-dotenv ==1.0.1
+Requires-Dist: setuptools ==71.0.0
+Requires-Dist: SQLAlchemy ==2.0.31
+Requires-Dist: typing-extensions ==4.12.2
+
+# Shared Kernel
+
+Shared Kernel is a lightweight, modular Python library designed to facilitate rapid development of microservices. It provides essential utilities for data manipulation, logging, configuration management, and database connectivity, making it an ideal foundation for building scalable and maintainable microservices.
+
+## Table of Contents
+
+- [Getting Started](#getting-started)
+  - [Prerequisites](#prerequisites)
+  - [Installation](#installation)
+- [Usage](#usage)
+  - [Importing Modules](#importing-modules)
+  - [Initializing Database Connection](#initializing-database-connection)
+
+
+## Getting Started
+
+### Prerequisites
+
+- Python 3.6+
+- Pip
+
+### Installation
+
+To install Shared Kernel, clone the repository and install it using pip:
+
+   ```sh
+   git clone https://bitbucket.org/Weavers/shared-kernel.git 
+   cd shared-kernel pip install .
+   ```
+
+##### Step 1: Set Up Your Environment
+First, ensure you have Python installed on your system. Then, set up a virtual environment for your project to manage dependencies cleanly. Open your terminal and navigate to your project directory:
+
+```sh
+cd path/to/shared-kernel
+python -m venv venv
+source venv/bin/activate  # On Windows, use `venv\Scripts\activate`
+```
+
+##### Step 2: Install Python build frontend.
+Ensure you python's build frontend. installed in your environment. This is necessary for building the wheel package from **.toml** file. You can install them using pip:
+```sh
+pip install --upgrade build
+```
+
+##### Step 3: Build the Wheel Package
+```sh
+python -m build
+```
+This command will build a wheel distribution and also a source distribution. After running this command, you'll find the .whl and a tar file inside the dist/ directory within your project folder.
+
+
+##### Step 4: Distribute the Wheel
+Now that you have a .whl file, you can distribute it to others. Users can install your library using pip by pointing to the .whl file:
+
+```sh
+pip install dist/shared_kernel-0.1.0-py3-none-any.whl
+```
+
+
+## Usage
+
+### Importing Modules
+
+Import the required modules from Shared Kernel into your project:
+
+```
+from shared_kernel.logger import Logger
+from shared_kernel.config import Config
+from dotenv import find_dotenv
+
+
+def main():
+    logger = Logger(name="my_app")
+    logger.configure_logger()
+
+    # Specify the path to the .env file if it's not in the current directory
+    config_manager = Config(env_path=find_dotenv())
+
+    # Access environment variables
+    api_key = config_manager.get("KEY", "default_api_key")
+
+    # Example usage
+    logger.logger.info("This is an info message.")
+    logger.logger.error("This is an error message.")
+    logger.logger.info(api_key)
+
+
+if __name__ == "__main__":
+    main()
+
+```
+
+
+### Initializing Database Connection
+
+Use the `DB` class to initialize a database connection:
+
+```
+from shared_kernel.DB import DB
+
+db_instance = DB("postgresql://user:password@localhost/dbname") 
+engine, SessionLocal = db_instance.init_db_connection()
+
+```
+
+
+
+
+### Initializing NATS Connection
+
+Use the `NATSClient` class to initialize a messaging connection:
+
+```
+from shared_kernel.messaging import NATSClient
+import asyncio
+
+def run():
+  nats_instance = NATSClient("nats://localhost:4222") 
+    await nc_interface.connect()
+
+    async def message_callback(data):
+        print(f"Received a message: {data}")
+
+    await nc_interface.subscribe("example_subject", message_callback)
+    await nc_interface.publish("example_subject", "Hello NATS!")
+    
+if __name__ == '__main__':
+    asyncio.run(run())
+```

fdc_shared_kernel-0.0.3.dist-info/RECORD

@@ -0,0 +1,33 @@
+shared_kernel/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shared_kernel/config/__init__.py,sha256=9PiY-e-lNE4eqO_wWcmyIhobHSTH8-aDNV3hNJSSLRw,1583
+shared_kernel/database/__init__.py,sha256=5jZGb1Vbzd7ZyblagiQNhvYiX86Fbx3azy1mDpG-BZs,1567
+shared_kernel/exceptions/__init__.py,sha256=yc2u7LPVGIr6G7SDee3rO2KBGnG6vVeCdpbSMAjVmKc,428
+shared_kernel/exceptions/configuration_exceptions.py,sha256=LFzOt3XKVpbeDP23-tQ4xYfThAOAmQAyDNLfWl-fnkQ,995
+shared_kernel/exceptions/custom_exceptions.py,sha256=MaZime3JejcpyJH-aQVmoGqvS4malLLgw2QX8ZUy7Xc,631
+shared_kernel/exceptions/data_validation_exceptions.py,sha256=IV_l_U2Dz6gJ2mNKY9Lw-sCSSm07eBmP0wSOG4ATEbU,1194
+shared_kernel/exceptions/http_exceptions.py,sha256=y_sz0VUD5kFLVExD9_TheaJl-89Pa0aUOF9WB0SL55k,2214
+shared_kernel/exceptions/infrastructure_exceptions.py,sha256=xti8u1KNgUezD0rKrvZh98TKdDkiaopVE9Dgi3GxXoI,1201
+shared_kernel/exceptions/operational_exceptions.py,sha256=ukz9EkLJ8PXAgLxfIL6zDITv9rbyT5fgV-ktNp8RooE,1007
+shared_kernel/exceptions/security_exceptions.py,sha256=lmgMLe9prLKSn1LCGJAJ5aoFsv4B1ttdO8jmZf1SCEA,1122
+shared_kernel/interfaces/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shared_kernel/interfaces/databus.py,sha256=SO1AlB84rVGzdmI5NC1kMu2pTqmbYbq5e_U7suBV2DI,1918
+shared_kernel/logger/__init__.py,sha256=yV0u1V8gIHrN7NQUAJyWm9p9w3m4dCLMsC94P-zQANQ,2435
+shared_kernel/messaging/__init__.py,sha256=fb5iy10OehXWGAR6clGfHirgrE5j8ZRlKjLXhVcPF4E,58
+shared_kernel/messaging/nats_databus.py,sha256=YTchy41S72XTk7Ttdcz9Sv8gmAjca2KUQLLKDkK_35g,5608
+shared_kernel/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shared_kernel/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+shared_kernel/tests/config/test_config.py,sha256=nuC48_D1SYBtA04q69WM4Q5McLHxNOWMWEjiMMqvTDo,1413
+shared_kernel/tests/logger/test_logger.py,sha256=2bi-k9N8AEhc_ShfRfej-hxU9-ipRG0VfvIe6Hw03vs,1713
+shared_kernel/tests/messaging/test_nats_interface.py,sha256=ESVyZv8eb-mDfXKzvCMyVBoiR4VzXmnWA0zfjbV5Tfw,1071
+shared_kernel/tests/utils/test_data_validators.py,sha256=VqA_qLBCa2AtQPQg6pkJko-MULwCyGIwgnRf8HvS7q8,628
+shared_kernel/tests/utils/test_date_format_utils.py,sha256=Efok35oJlIpT7EF0IYb1MEwuZ1SY8eiqu8iKm8JzgE8,568
+shared_kernel/tests/utils/test_string_utils.py,sha256=F4bfWTqjfZl6SGe_axNIMr74yXx0G-q95HnnSkY5THg,992
+shared_kernel/tests/utils/utils.py,sha256=7r6jXZACNyfyBUyalyFB2JSJ_0ziYJeS_jteV_xGmpw,17101
+shared_kernel/utils/__init__.py,sha256=6plsQ8FreOHaDhvKlvRAwu52A3ROXLyu1be0oAq24V4,155
+shared_kernel/utils/data_validators_utils.py,sha256=kbSpgY2sNCg-nUsnTLQYy-9UyOVet2bA-lI1IqQB1Wg,394
+shared_kernel/utils/date_format_utils.py,sha256=OqPtncuPulLGWVv3X0IIOin-ECoWdtll3esWEVpaNMI,426
+shared_kernel/utils/string_utils.py,sha256=m-ZpJmN8yTc1nEc0kFDXu_m5uWl-MZf54rWw1D39IL8,850
+fdc_shared_kernel-0.0.3.dist-info/METADATA,sha256=FiIoEbkfpJ854nMr_hIUiCJ39fwUOsQBHK6tDawpsvo,4479
+fdc_shared_kernel-0.0.3.dist-info/WHEEL,sha256=Wyh-_nZ0DJYolHNn1_hMa4lM7uDedD_RGVwbmTjyItk,91
+fdc_shared_kernel-0.0.3.dist-info/top_level.txt,sha256=lKSOEkyFzaMd58KLHqJF-8tmK54xxWRcgmbPE9CuaKM,14
+fdc_shared_kernel-0.0.3.dist-info/RECORD,,

fdc_shared_kernel-0.0.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (71.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

fdc_shared_kernel-0.0.3.dist-info/top_level.txt

@@ -0,0 +1 @@
+shared_kernel

shared_kernel/config/__init__.py

@@ -0,0 +1,49 @@
+import os
+from typing import Any
+from dotenv import load_dotenv, find_dotenv
+from shared_kernel.exceptions import MissingConfiguration, InvalidConfiguration
+import logging
+
+logging.basicConfig(level=logging.INFO)
+
+
+class Config:
+
+    _instance = None
+
+    def __new__(cls, env_path=None):
+        if cls._instance is None:
+            cls._instance = super(Config, cls).__new__(cls)
+            cls._instance._initialize(env_path)
+        return cls._instance
+
+    def _initialize(self, env_path=None):
+        """
+        Initializes the Config class with an optional path to the .env file.
+
+        :param env_path: Optional path to the .env file. Defaults to finding the .env file in the current directory.
+        """
+        if env_path is None:
+            dotenv_path = find_dotenv()
+            if not dotenv_path:
+                logging.error(".env file not found")
+                raise InvalidConfiguration(".env file not found")
+        else:
+            dotenv_path = env_path
+
+        logging.info(f"Loading environment variables from {dotenv_path}")
+        load_dotenv(dotenv_path)
+
+    @staticmethod
+    def get(key: str, default: Any = None) -> Any:
+        """
+        Retrieves the value of an environment variable.
+
+        :param key: The name of the environment variable.
+        :param default: Default value to return if the environment variable is not set.
+        :return: The value of the environment variable.
+        """
+        value = os.getenv(key, default)
+        if value is None:
+            raise MissingConfiguration(key)
+        return value

shared_kernel/database/__init__.py

@@ -0,0 +1,43 @@
+from sqlalchemy import create_engine
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from shared_kernel.logger import Logger
+from typing import Tuple
+
+
+class DB:
+    def __init__(self, db_url: str):
+        """
+        Initializes the DB class with the provided database configuration.
+
+        :param db_url: The database URL (e.g., postgresql://user:password@localhost/dbname).
+        """
+        self.engine = create_engine(db_url, pool_size=20, max_overflow=100)
+        self.SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=self.engine)
+        self.Base = declarative_base()
+        self.logger = Logger(name="database")
+        self.logger.configure_logger()
+
+    def init_db_connection(self) -> Tuple[create_engine, sessionmaker]:
+        """
+        Initializes the database connection and returns the engine and session maker.
+
+        :return: A tuple containing the SQLAlchemy engine and session maker.
+        """
+        self.logger.info("Database connection initialized successfully.")
+        return self.engine, self.SessionLocal
+
+    def create_tables(self):
+        """
+        Creates all tables stored in declarative Base.
+        """
+        self.logger.info("Creating tables...")
+        self.Base.metadata.create_all(bind=self.engine)
+        self.logger.info("Tables created successfully.")
+
+    def close_session(self):
+        """
+        Closes the database session.
+        """
+        self.SessionLocal.remove()
+        self.logger.info("Session closed successfully.")

shared_kernel/exceptions/__init__.py

@@ -0,0 +1,7 @@
+from shared_kernel.exceptions.configuration_exceptions import *
+from shared_kernel.exceptions.custom_exceptions import *
+from shared_kernel.exceptions.data_validation_exceptions import *
+from shared_kernel.exceptions.http_exceptions import *
+from shared_kernel.exceptions.infrastructure_exceptions import *
+from shared_kernel.exceptions.operational_exceptions import *
+from shared_kernel.exceptions.security_exceptions import *

shared_kernel/exceptions/configuration_exceptions.py

@@ -0,0 +1,20 @@
+class ConfigurationException(Exception):
+    """Base class for all configuration exceptions."""
+    def __init__(self, message: str = "", config_key: str = "") -> None:
+        super().__init__(message)
+        self.config_key = config_key
+
+    def __str__(self) -> str:
+        return f"{type(self).__name__}: {self.args[0]} (Config Key: {self.config_key})"
+
+
+class MissingConfiguration(ConfigurationException):
+    """Raised when a required configuration setting is missing."""
+    def __init__(self, message: str = "Required configuration setting is missing", config_key: str = "") -> None:
+        super().__init__(message=message, config_key=config_key)
+
+
+class InvalidConfiguration(ConfigurationException):
+    """Raised when a configuration setting is invalid."""
+    def __init__(self, message: str = "Invalid configuration setting", config_key: str = "", valid_value: str = "") -> None:
+        super().__init__(message=f"{message} (Valid Value: {valid_value})", config_key=config_key)

shared_kernel/exceptions/custom_exceptions.py

@@ -0,0 +1,14 @@
+class BaseCustomException(Exception):
+    """Base class for all custom logic exceptions."""
+    def __init__(self, message: str = "", details: str = "") -> None:
+        super().__init__(message)
+        self.details = details
+
+    def __str__(self) -> str:
+        return f"{type(self).__name__}: {self.args[0]} (Details: {self.details})"
+
+
+class UnsupportedProfiling(BaseCustomException):
+    """Raised when an unsupported data profiling method is requested."""
+    def __init__(self, message: str = "The profiling method is not supported.", details: str = "") -> None:
+        super().__init__(message=message, details=details)

shared_kernel/exceptions/data_validation_exceptions.py

@@ -0,0 +1,26 @@
+class DataValidationException(Exception):
+    """Base class for all data validation exceptions."""
+    def __init__(self, message: str = "", field: str = "") -> None:
+        super().__init__(message)
+        self.field = field
+
+    def __str__(self) -> str:
+        return f"{type(self).__name__}: {self.args[0]} (Field: {self.field})"
+
+
+class MissingField(DataValidationException):
+    """Raised when a required field is missing."""
+    def __init__(self, message: str = "Required field is missing", field: str = "") -> None:
+        super().__init__(message=message, field=field)
+
+
+class IncorrectDataType(DataValidationException):
+    """Raised when the data type of a field is incorrect."""
+    def __init__(self, message: str = "Incorrect data type", field: str = "", expected_type: str = "") -> None:
+        super().__init__(message=f"{message} (Expected: {expected_type})", field=field)
+
+
+class InvalidValue(DataValidationException):
+    """Raised when the value of a field is invalid."""
+    def __init__(self, message: str = "Invalid value", field: str = "", valid_values: str = "") -> None:
+        super().__init__(message=f"{message} (Valid Values: {valid_values})", field=field)

shared_kernel/exceptions/http_exceptions.py

@@ -0,0 +1,60 @@
+import http
+
+
+class HTTPException(Exception):
+    """Base class for all HTTP exceptions."""
+
+    def __init__(self, message: str = "", status_code: int = None) -> None:
+        super().__init__(message)
+        self.status_code = status_code
+
+    def __str__(self) -> str:
+        return f"{self.status_code}: {super().__str__()}"
+
+
+class BadRequest(HTTPException):
+    """Raised for HTTP 400 Bad Request errors."""
+    status_code = http.HTTPStatus.BAD_REQUEST.value
+
+    def __init__(self, message: str = "Bad Request", status_code: int = None) -> None:
+        super().__init__(message=message, status_code=status_code or self.status_code)
+
+
+class Unauthorized(HTTPException):
+    """Raised for HTTP 401 Unauthorized errors."""
+    status_code = http.HTTPStatus.UNAUTHORIZED.value
+
+    def __init__(self, message: str = "Unauthorized", status_code: int = None) -> None:
+        super().__init__(message=message, status_code=status_code or self.status_code)
+
+
+class Forbidden(HTTPException):
+    """Raised for HTTP 403 Forbidden errors."""
+    status_code = http.HTTPStatus.FORBIDDEN.value
+
+    def __init__(self, message: str = "Forbidden", status_code: int = None) -> None:
+        super().__init__(message=message, status_code=status_code or self.status_code)
+
+
+class NotFound(HTTPException):
+    """Raised for HTTP 404 Not Found errors."""
+    status_code = http.HTTPStatus.NOT_FOUND.value
+
+    def __init__(self, message: str = "Not Found", status_code: int = None) -> None:
+        super().__init__(message=message, status_code=status_code or self.status_code)
+
+
+class Conflict(HTTPException):
+    """Raised for HTTP 409 Conflict errors."""
+    status_code = http.HTTPStatus.CONFLICT.value
+
+    def __init__(self, message: str = "Conflict", status_code: int = None) -> None:
+        super().__init__(message=message, status_code=status_code or self.status_code)
+
+
+class InternalServerError(HTTPException):
+    """Raised for HTTP 500 Internal Server Error."""
+    status_code = http.HTTPStatus.INTERNAL_SERVER_ERROR.value
+
+    def __init__(self, message: str = "Internal Server Error", status_code: int = None) -> None:
+        super().__init__(message=message, status_code=status_code or self.status_code)

shared_kernel/exceptions/infrastructure_exceptions.py

@@ -0,0 +1,26 @@
+class InfrastructureException(Exception):
+    """Base class for all infrastructure exceptions."""
+    def __init__(self, message: str = "", resource: str = "") -> None:
+        super().__init__(message)
+        self.resource = resource
+
+    def __str__(self) -> str:
+        return f"{type(self).__name__}: {self.args[0]} (Resource: {self.resource})"
+
+
+class DatabaseConnectionError(InfrastructureException):
+    """Raised when there is an issue connecting to the database."""
+    def __init__(self, message: str = "Failed to connect to the database", resource: str = "database") -> None:
+        super().__init__(message=message, resource=resource)
+
+
+class FileNotFoundError(InfrastructureException):
+    """Raised when a required file or directory cannot be found."""
+    def __init__(self, message: str = "File or directory not found", resource: str = "") -> None:
+        super().__init__(message=message, resource=resource)
+
+
+class NetworkError(InfrastructureException):
+    """Raised when there is a network connectivity issue."""
+    def __init__(self, message: str = "Network connectivity issue", resource: str = "network") -> None:
+        super().__init__(message=message, resource=resource)

shared_kernel/exceptions/operational_exceptions.py

@@ -0,0 +1,26 @@
+class OperationalException(Exception):
+    """Base class for all operational exceptions."""
+    def __init__(self, message: str = "", cause=None) -> None:
+        super().__init__(message)
+        self.cause = cause
+
+    def __str__(self) -> str:
+        return f"{type(self).__name__}: {self.args[0]}"
+
+
+class ServiceUnavailable(OperationalException):
+    """Raised when the service is temporarily unavailable."""
+    def __init__(self, message: str = "Service Unavailable", cause=None) -> None:
+        super().__init__(message=message, cause=cause)
+
+
+class Timeout(OperationalException):
+    """Raised when an operation times out."""
+    def __init__(self, message: str = "Operation Timed Out", cause=None) -> None:
+        super().__init__(message=message, cause=cause)
+
+
+class RateLimitExceeded(OperationalException):
+    """Raised when a rate limit is exceeded."""
+    def __init__(self, message: str = "Rate Limit Exceeded", cause=None) -> None:
+        super().__init__(message=message, cause=cause)

shared_kernel/exceptions/security_exceptions.py

@@ -0,0 +1,26 @@
+class SecurityException(Exception):
+    """Base class for all security exceptions."""
+    def __init__(self, message: str = "", detail: str = "") -> None:
+        super().__init__(message)
+        self.detail = detail
+
+    def __str__(self) -> str:
+        return f"{type(self).__name__}: {self.args[0]} (Detail: {self.detail})"
+
+
+class PermissionDenied(SecurityException):
+    """Raised when a user tries to access a resource without sufficient permissions."""
+    def __init__(self, message: str = "Access Denied", detail: str = "") -> None:
+        super().__init__(message=message, detail=detail)
+
+
+class EncryptionError(SecurityException):
+    """Raised when there is an issue with encryption or decryption."""
+    def __init__(self, message: str = "Encryption Error", detail: str = "") -> None:
+        super().__init__(message=message, detail=detail)
+
+
+class CertificateVerificationError(SecurityException):
+    """Raised when SSL certificate verification fails."""
+    def __init__(self, message: str = "SSL Verification Failed", detail: str = "") -> None:
+        super().__init__(message=message, detail=detail)

shared_kernel/interfaces/databus.py

@@ -0,0 +1,73 @@
+from abc import ABC, abstractmethod
+from typing import Any, Callable
+
+
+class DataBus(ABC):
+    """
+    A Databus Interface class to handle both async messaging and synchronous messaging.
+    """
+
+    @abstractmethod
+    def __init__(self) -> None:
+        pass
+
+    @abstractmethod
+    def make_connection(self):
+        """
+        Connect to the Databus server.
+        """
+        pass
+
+    @abstractmethod
+    def close_connection(self):
+        """
+        Close connection from the Databus server.
+        """
+        pass
+
+    @abstractmethod
+    def publish_event(self, topic: str, event_payload: dict):
+        """
+        Publish an async message to a Databus topic.
+
+        Args:
+            topic (str): The topic to publish the message to.
+            event_payload (dict): The message to be published.
+        """
+        pass
+
+    @abstractmethod
+    def request_event(self, topic, event_payload):
+        """
+        Send a synchronous request/message to a Databus topic and recieve response.
+
+        Args:
+            topic (str): The topic to publish the message to.
+            event_payload (dict): The message to be published.
+
+        Returns:
+            response (Any): response message
+        """
+        pass
+
+    @abstractmethod
+    def subscribe_sync_event(self, topic, callback: Callable[[Any], None]):
+        """
+        Subscribe to a databus topic and process messages synchronously.
+
+        Args:
+            topic: The topic to subscribe to.
+            callback: A callback function to handle received messages.
+        """
+        pass
+
+    @abstractmethod
+    def subscribe_async_event(self, topic, callback: Callable[[Any], None]):
+        """
+        Subscribe to a databus topic and process messages asynchronously.
+
+        Args:
+            topic: The topic to subscribe to.
+            callback: A callback function to handle received messages.
+        """
+        pass

shared_kernel/logger/__init__.py

@@ -0,0 +1,75 @@
+import logging
+import os
+
+
+class Logger:
+    """
+    A singleton logger class that ensures only one logger instance is created.
+    This logger supports both console and file logging.
+
+    Attributes:
+        _instance (Optional[Logger]): The single instance of the logger.
+    """
+
+    _instance = None
+
+    def __new__(cls, name=None):
+        """
+        override __new__ to ensure singleton pattern.
+        """
+        if cls._instance is None:
+            cls._instance = super(Logger, cls).__new__(cls)
+            cls._instance._initialize(name=name)
+        return cls._instance
+
+    def _initialize(self, name=None, log_file: str = "fdc_app_logs.log"):
+
+        self.logger = logging.getLogger(name if name else __name__)
+        self.logger.setLevel(logging.DEBUG)
+        self.formatter = logging.Formatter(
+            "%(asctime)s - %(name)s - %(filename)s - %(module)s - %(levelname)s - %(message)s"
+        )
+        self.log_file = log_file
+
+        # ensure handlers are configured only once
+        if not self.logger.handlers:
+            self.configure_logger()
+
+    def configure_logger(self):
+        """
+        Configures logger with stream and file handlers.
+        """
+        self.add_stream_handler()
+        self.add_file_handler(log_file=self.log_file)
+
+    def add_stream_handler(self):
+        """
+        Adds a stream handler to the logger.
+        """
+        stream_handler = logging.StreamHandler()
+        stream_handler.setLevel(self.logger.level)
+        stream_handler.setFormatter(self.formatter)
+        self.logger.addHandler(stream_handler)
+
+    def add_file_handler(self, log_file, log_directory="./logs"):
+        """
+        Adds a file handler to the logger.
+        """
+        if not os.path.exists(log_directory):
+            os.makedirs(log_directory)
+        file_handler = logging.FileHandler(os.path.join(log_directory, log_file))
+        file_handler.setLevel(self.logger.level)
+        file_handler.setFormatter(self.formatter)
+        self.logger.addHandler(file_handler)
+
+    def info(self, message, *args, **kwargs):
+        self.logger.info(message, *args, **kwargs)
+
+    def error(self, message, *args, **kwargs):
+        self.logger.error(message, *args, **kwargs)
+
+    def debug(self, message, *args, **kwargs):
+        self.logger.debug(message, *args, **kwargs)
+
+    def warning(self, message, *args, **kwargs):
+        self.logger.warning(message, *args, **kwargs)

shared_kernel/messaging/__init__.py

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