fdc-shared-kernel 0.0.6__tar.gz → 0.0.9__tar.gz

{fdc_shared_kernel-0.0.6 → fdc_shared_kernel-0.0.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fdc_shared_kernel
-Version: 0.0.6
+Version: 0.0.9
 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
@@ -111,7 +111,7 @@ engine, SessionLocal = db_instance.init_db_connection()
 
 ### Initializing NATS Connection
 
-Use the `NATSClient` class to initialize a messaging connection:
+Use the `NATSClient` class to initialize:
 
 ```
 from shared_kernel.messaging import NATSClient
@@ -130,3 +130,74 @@ def run():
 if __name__ == '__main__':
     asyncio.run(run())
 ```
+
+
+### Using Keyvault Manager
+
+Use the `KeyVaultManager` class to initialize:
+
+```
+from shared_kernel.security import KeyVaultManager
+
+def run():
+    aws_vault = KeyVaultManager.create_key_vault('aws', {
+        'region_name': 'us-east-1',
+        'AWS_SERVER_PUBLIC_KEY': '<key here>',
+        'AWS_SERVER_SECRET_KEY': '<secret here>'
+    })
+    # AWS Secrets Manager operations
+    aws_vault.store_secret("fdc_api_key", "123456")
+    
+    print(aws_vault.retrieve_secret("fdc_api_key"))  # Output: 123456
+    
+    print(aws_vault.list_secrets())  # Output: ['fdc_api_key']
+    
+    aws_vault.delete_secret("api_key")
+    print(aws_vault.list_secrets())  # Output: []
+if __name__ == '__main__':
+    run()
+```
+
+
+### Using JWT Token handler
+
+Use the `JWTTokenHandler` class to initialize:
+
+```
+from shared_kernel.security import JWTTokenHandler
+
+def run():
+  secret_key = 'your-secret-key'
+  token_handler = JWTTokenHandler(secret_key)
+  payload = token_handler.decode_token('your-jwt-token')
+
+if __name__ == '__main__':
+    run()
+```
+
+### Using JWTTokenHandler
+
+Use the `JWTTokenHandler` class to initialize:
+
+```
+from shared_kernel.auth import JWTTokenHandler
+
+def run():
+  secret_key = 'your-secret-key'
+  token_handler = JWTTokenHandler(secret_key)
+  payload = token_handler.decode_token('your-jwt-token')
+if __name__ == '__main__':
+    run()
+```
+
+In routes
+
+```
+from shared_kernel.auth import token_required
+
+@app.route('/')
+@token_required
+def user(current_user):
+  return jsonify(current_user)
+```
+

{fdc_shared_kernel-0.0.6 → fdc_shared_kernel-0.0.9}/README.md

@@ -109,7 +109,7 @@ engine, SessionLocal = db_instance.init_db_connection()
 
 ### Initializing NATS Connection
 
-Use the `NATSClient` class to initialize a messaging connection:
+Use the `NATSClient` class to initialize:
 
 ```
 from shared_kernel.messaging import NATSClient
@@ -127,4 +127,75 @@ def run():
     
 if __name__ == '__main__':
     asyncio.run(run())
-```
+```
+
+
+### Using Keyvault Manager
+
+Use the `KeyVaultManager` class to initialize:
+
+```
+from shared_kernel.security import KeyVaultManager
+
+def run():
+    aws_vault = KeyVaultManager.create_key_vault('aws', {
+        'region_name': 'us-east-1',
+        'AWS_SERVER_PUBLIC_KEY': '<key here>',
+        'AWS_SERVER_SECRET_KEY': '<secret here>'
+    })
+    # AWS Secrets Manager operations
+    aws_vault.store_secret("fdc_api_key", "123456")
+    
+    print(aws_vault.retrieve_secret("fdc_api_key"))  # Output: 123456
+    
+    print(aws_vault.list_secrets())  # Output: ['fdc_api_key']
+    
+    aws_vault.delete_secret("api_key")
+    print(aws_vault.list_secrets())  # Output: []
+if __name__ == '__main__':
+    run()
+```
+
+
+### Using JWT Token handler
+
+Use the `JWTTokenHandler` class to initialize:
+
+```
+from shared_kernel.security import JWTTokenHandler
+
+def run():
+  secret_key = 'your-secret-key'
+  token_handler = JWTTokenHandler(secret_key)
+  payload = token_handler.decode_token('your-jwt-token')
+
+if __name__ == '__main__':
+    run()
+```
+
+### Using JWTTokenHandler
+
+Use the `JWTTokenHandler` class to initialize:
+
+```
+from shared_kernel.auth import JWTTokenHandler
+
+def run():
+  secret_key = 'your-secret-key'
+  token_handler = JWTTokenHandler(secret_key)
+  payload = token_handler.decode_token('your-jwt-token')
+if __name__ == '__main__':
+    run()
+```
+
+In routes
+
+```
+from shared_kernel.auth import token_required
+
+@app.route('/')
+@token_required
+def user(current_user):
+  return jsonify(current_user)
+```
+

{fdc_shared_kernel-0.0.6 → fdc_shared_kernel-0.0.9}/README_pypi.md

@@ -78,7 +78,7 @@ engine, SessionLocal = db_instance.init_db_connection()
 
 ### Initializing NATS Connection
 
-Use the `NATSClient` class to initialize a messaging connection:
+Use the `NATSClient` class to initialize:
 
 ```
 from shared_kernel.messaging import NATSClient
@@ -96,4 +96,75 @@ def run():
     
 if __name__ == '__main__':
     asyncio.run(run())
-```
+```
+
+
+### Using Keyvault Manager
+
+Use the `KeyVaultManager` class to initialize:
+
+```
+from shared_kernel.security import KeyVaultManager
+
+def run():
+    aws_vault = KeyVaultManager.create_key_vault('aws', {
+        'region_name': 'us-east-1',
+        'AWS_SERVER_PUBLIC_KEY': '<key here>',
+        'AWS_SERVER_SECRET_KEY': '<secret here>'
+    })
+    # AWS Secrets Manager operations
+    aws_vault.store_secret("fdc_api_key", "123456")
+    
+    print(aws_vault.retrieve_secret("fdc_api_key"))  # Output: 123456
+    
+    print(aws_vault.list_secrets())  # Output: ['fdc_api_key']
+    
+    aws_vault.delete_secret("api_key")
+    print(aws_vault.list_secrets())  # Output: []
+if __name__ == '__main__':
+    run()
+```
+
+
+### Using JWT Token handler
+
+Use the `JWTTokenHandler` class to initialize:
+
+```
+from shared_kernel.security import JWTTokenHandler
+
+def run():
+  secret_key = 'your-secret-key'
+  token_handler = JWTTokenHandler(secret_key)
+  payload = token_handler.decode_token('your-jwt-token')
+
+if __name__ == '__main__':
+    run()
+```
+
+### Using JWTTokenHandler
+
+Use the `JWTTokenHandler` class to initialize:
+
+```
+from shared_kernel.auth import JWTTokenHandler
+
+def run():
+  secret_key = 'your-secret-key'
+  token_handler = JWTTokenHandler(secret_key)
+  payload = token_handler.decode_token('your-jwt-token')
+if __name__ == '__main__':
+    run()
+```
+
+In routes
+
+```
+from shared_kernel.auth import token_required
+
+@app.route('/')
+@token_required
+def user(current_user):
+  return jsonify(current_user)
+```
+

{fdc_shared_kernel-0.0.6 → fdc_shared_kernel-0.0.9}/pyproject.toml

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

{fdc_shared_kernel-0.0.6 → fdc_shared_kernel-0.0.9}/src/fdc_shared_kernel.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fdc_shared_kernel
-Version: 0.0.6
+Version: 0.0.9
 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
@@ -111,7 +111,7 @@ engine, SessionLocal = db_instance.init_db_connection()
 
 ### Initializing NATS Connection
 
-Use the `NATSClient` class to initialize a messaging connection:
+Use the `NATSClient` class to initialize:
 
 ```
 from shared_kernel.messaging import NATSClient
@@ -130,3 +130,74 @@ def run():
 if __name__ == '__main__':
     asyncio.run(run())
 ```
+
+
+### Using Keyvault Manager
+
+Use the `KeyVaultManager` class to initialize:
+
+```
+from shared_kernel.security import KeyVaultManager
+
+def run():
+    aws_vault = KeyVaultManager.create_key_vault('aws', {
+        'region_name': 'us-east-1',
+        'AWS_SERVER_PUBLIC_KEY': '<key here>',
+        'AWS_SERVER_SECRET_KEY': '<secret here>'
+    })
+    # AWS Secrets Manager operations
+    aws_vault.store_secret("fdc_api_key", "123456")
+    
+    print(aws_vault.retrieve_secret("fdc_api_key"))  # Output: 123456
+    
+    print(aws_vault.list_secrets())  # Output: ['fdc_api_key']
+    
+    aws_vault.delete_secret("api_key")
+    print(aws_vault.list_secrets())  # Output: []
+if __name__ == '__main__':
+    run()
+```
+
+
+### Using JWT Token handler
+
+Use the `JWTTokenHandler` class to initialize:
+
+```
+from shared_kernel.security import JWTTokenHandler
+
+def run():
+  secret_key = 'your-secret-key'
+  token_handler = JWTTokenHandler(secret_key)
+  payload = token_handler.decode_token('your-jwt-token')
+
+if __name__ == '__main__':
+    run()
+```
+
+### Using JWTTokenHandler
+
+Use the `JWTTokenHandler` class to initialize:
+
+```
+from shared_kernel.auth import JWTTokenHandler
+
+def run():
+  secret_key = 'your-secret-key'
+  token_handler = JWTTokenHandler(secret_key)
+  payload = token_handler.decode_token('your-jwt-token')
+if __name__ == '__main__':
+    run()
+```
+
+In routes
+
+```
+from shared_kernel.auth import token_required
+
+@app.route('/')
+@token_required
+def user(current_user):
+  return jsonify(current_user)
+```
+

{fdc_shared_kernel-0.0.6 → fdc_shared_kernel-0.0.9}/src/fdc_shared_kernel.egg-info/SOURCES.txt

@@ -8,6 +8,9 @@ src/fdc_shared_kernel.egg-info/dependency_links.txt
 src/fdc_shared_kernel.egg-info/requires.txt
 src/fdc_shared_kernel.egg-info/top_level.txt
 src/shared_kernel/__init__.py
+src/shared_kernel/auth/__init__.py
+src/shared_kernel/auth/jwt_helper.py
+src/shared_kernel/auth/token_handler.py
 src/shared_kernel/config/__init__.py
 src/shared_kernel/database/__init__.py
 src/shared_kernel/exceptions/__init__.py

fdc_shared_kernel-0.0.9/src/shared_kernel/auth/__init__.py

@@ -0,0 +1,2 @@
+from shared_kernel.auth.jwt_helper import JWTTokenHandler
+from shared_kernel.auth.token_handler import token_required

fdc_shared_kernel-0.0.9/src/shared_kernel/auth/jwt_helper.py

@@ -0,0 +1,44 @@
+import jwt
+from shared_kernel.exceptions import Unauthorized
+
+
+class JWTTokenHandler:
+    _instance = None
+
+    def __new__(cls, secret_key: str = None):
+        if cls._instance is None:
+            if secret_key is None:
+                raise ValueError("Secret key must be provided for the first initialization.")
+            cls._instance = super(JWTTokenHandler, cls).__new__(cls)
+            cls._instance._initialize(secret_key)
+        return cls._instance
+
+    def _initialize(self, secret_key: str):
+        """
+        Initialize the JWTTokenHandler with a secret key.
+
+        Args:
+            secret_key (str): The secret key used for decoding and verifying JWT tokens.
+        """
+        self.secret_key = secret_key
+
+    def decode_token(self, token: str) -> dict:
+        """
+        Decode and verify a JWT token using the provided secret key.
+
+        Args:
+            token (str): The JWT token to be decoded.
+
+        Returns:
+            dict: The payload of the decoded token.
+
+        Raises:
+            Unauthorized: If the token is expired or invalid.
+        """
+        try:
+            payload = jwt.decode(token, self.secret_key, algorithms=['HS256'])
+            return payload
+        except jwt.ExpiredSignatureError:
+            raise Unauthorized('Token expired')
+        except jwt.InvalidTokenError:
+            raise Unauthorized('Invalid token')

fdc_shared_kernel-0.0.9/src/shared_kernel/auth/token_handler.py

@@ -0,0 +1,31 @@
+from flask import request
+from shared_kernel.auth import JWTTokenHandler
+from shared_kernel.config import Config
+from shared_kernel.exceptions import Unauthorized
+
+config = Config()
+token_handler = JWTTokenHandler(config.get('JWT_SECRET_KEY'))
+
+
+# Decorator to protect routes
+def token_required(f):
+    def decorator(*args, **kwargs):
+        token = None
+        if 'Authorization' in request.headers:
+            token = request.headers['Authorization'].replace('Bearer ', '')
+
+        if not token:
+            raise Unauthorized('Token is missing!')
+
+        payload = token_handler.decode_token(token)
+        if 'error' in payload:
+            raise Unauthorized("Failed to parse token")
+
+        # Add user information to the request context
+        current_user = {
+            "user_id": payload['user_id'],
+            "org_id": payload['org_id']
+        }
+        return f(current_user, *args, **kwargs)
+
+    return decorator

{fdc_shared_kernel-0.0.6 → fdc_shared_kernel-0.0.9}/src/shared_kernel/config/__init__.py

@@ -1,10 +1,8 @@
 import os
+import logging
 from typing import Any
 from dotenv import load_dotenv, find_dotenv
 from shared_kernel.exceptions import MissingConfiguration, InvalidConfiguration
-from shared_kernel.logger import Logger
-
-logger = Logger('SHARED_KERNEL')
 
 
 class Config:
@@ -26,12 +24,12 @@ class Config:
         if env_path is None:
             dotenv_path = find_dotenv()
             if not dotenv_path:
-                logger.error(".env file not found")
+                logging.error(".env file not found")
                 raise InvalidConfiguration(".env file not found")
         else:
             dotenv_path = env_path
 
-        logger.info(f"Loading environment variables from {dotenv_path}")
+        logging.info(f"Loading environment variables from {dotenv_path}")
         load_dotenv(dotenv_path)
 
     @staticmethod

{fdc_shared_kernel-0.0.6 → fdc_shared_kernel-0.0.9}/src/shared_kernel/database/__init__.py

@@ -1,7 +1,7 @@
+import logging
 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
 
 
@@ -15,8 +15,6 @@ class DB:
         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]:
         """
@@ -24,20 +22,20 @@ class DB:
 
         :return: A tuple containing the SQLAlchemy engine and session maker.
         """
-        self.logger.info("Database connection initialized successfully.")
+        logging.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...")
+        logging.info("Creating tables...")
         self.Base.metadata.create_all(bind=self.engine)
-        self.logger.info("Tables created successfully.")
+        logging.info("Tables created successfully.")
 
     def close_session(self):
         """
         Closes the database session.
         """
         self.SessionLocal.remove()
-        self.logger.info("Session closed successfully.")
+        logging.info("Session closed successfully.")

fdc_shared_kernel-0.0.9/src/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 = "", code: int = None) -> None:
+        super().__init__(message)
+        self.code = code
+
+    def __str__(self) -> str:
+        return f"{super().__str__()}"
+
+
+class BadRequest(HTTPException):
+    """Raised for HTTP 400 Bad Request errors."""
+    code = http.HTTPStatus.BAD_REQUEST.value
+
+    def __init__(self, message: str = "Bad Request", code: int = 400) -> None:
+        super().__init__(message=message, code=code or self.code)
+
+
+class Unauthorized(HTTPException):
+    """Raised for HTTP 401 Unauthorized errors."""
+    code = http.HTTPStatus.UNAUTHORIZED.value
+
+    def __init__(self, message: str = "Unauthorized", code: int = 400) -> None:
+        super().__init__(message=message, code=code or self.code)
+
+
+class Forbidden(HTTPException):
+    """Raised for HTTP 403 Forbidden errors."""
+    code = http.HTTPStatus.FORBIDDEN.value
+
+    def __init__(self, message: str = "Forbidden", code: int = 403) -> None:
+        super().__init__(message=message, code=code or self.code)
+
+
+class NotFound(HTTPException):
+    """Raised for HTTP 404 Not Found errors."""
+    code = http.HTTPStatus.NOT_FOUND.value
+
+    def __init__(self, message: str = "Not Found", code: int = 404) -> None:
+        super().__init__(message=message, code=code or self.code)
+
+
+class Conflict(HTTPException):
+    """Raised for HTTP 409 Conflict errors."""
+    code = http.HTTPStatus.CONFLICT.value
+
+    def __init__(self, message: str = "Conflict", code: int = 409) -> None:
+        super().__init__(message=message, code=code or self.code)
+
+
+class InternalServerError(HTTPException):
+    """Raised for HTTP 500 Internal Server Error."""
+    code = http.HTTPStatus.INTERNAL_SERVER_ERROR.value
+
+    def __init__(self, message: str = "Internal Server Error", code: int = 500) -> None:
+        super().__init__(message=message, code=code or self.code)

{fdc_shared_kernel-0.0.6 → fdc_shared_kernel-0.0.9}/src/shared_kernel/messaging/nats_databus.py

@@ -1,9 +1,9 @@
 import json
+import logging
 from nats.aio.client import Client as NATS
 from nats.js.api import ConsumerConfig, DeliverPolicy, StreamConfig
 from typing import Callable, Any, List, Union
 from shared_kernel.interfaces import DataBus
-from shared_kernel.logger import Logger
 
 
 class NATSDataBus(DataBus):
@@ -32,7 +32,6 @@ class NATSDataBus(DataBus):
             self.connected = False
             self.js = None  # JetStream context
             self.initialized = True
-            self.logger = Logger('SHARED_KERNEL')
 
     async def make_connection(self):
         """
@@ -90,12 +89,12 @@ class NATSDataBus(DataBus):
             ack = await self.js.publish(
                 topic, json.dumps(event_payload).encode("utf-8")
             )
-            self.logger.info(
+            logging.info(
                 f"Published event '{event_payload.get('event_name')}' to topic '{topic}', ack: {ack}"
             )
             return True
         except Exception as e:
-            self.logger.error(
+            logging.error(
                 f"Failed to publish event '{event_payload.get('event_name')}': {str(e)}",
                 exc_info=True,
             )
@@ -121,7 +120,7 @@ class NATSDataBus(DataBus):
             )
             return json.loads(response.data.decode("utf-8"))
         except Exception as e:
-            self.logger.error(f"Failed to request topic '{topic}': {e}", exc_info=True)
+            logging.error(f"Failed to request topic '{topic}': {e}", exc_info=True)
             raise e
 
     async def subscribe_async_event(
@@ -144,10 +143,10 @@ class NATSDataBus(DataBus):
             )
 
             await self.js.subscribe(topic, cb=callback, config=consumer_config)
-            self.logger.info(f"Subscribed to async event on topic '{topic}'")
+            logging.info(f"Subscribed to async event on topic '{topic}'")
 
         except Exception as e:
-            self.logger.error(
+            logging.error(
                 f"Failed to subscribe to async event on topic '{topic}': {e}",
                 exc_info=True,
             )
@@ -163,10 +162,10 @@ class NATSDataBus(DataBus):
         """
         try:
             await self.nc.subscribe(topic, cb=callback)
-            self.logger.info(f"Subscribed to sync event on topic '{topic}'")
+            logging.info(f"Subscribed to sync event on topic '{topic}'")
 
         except Exception as e:
-            self.logger.error(
+            logging.error(
                 f"Failed to subscribe to sync event on topic '{topic}': {e}",
                 exc_info=True,
             )

{fdc_shared_kernel-0.0.6 → fdc_shared_kernel-0.0.9}/src/shared_kernel/security/key_vault/__init__.py

@@ -3,7 +3,7 @@ from shared_kernel.security.key_vault.aws_secret_manager import AWSSecretsManage
 from shared_kernel.security.key_vault.azure_keyvault import AzureKeyVault
 
 
-class KeyVaultFactory:
+class KeyVaultManager:
     @staticmethod
     def create_key_vault(vault_type: str, config: dict) -> KeyVaultInterface:
         if vault_type == 'AZURE':

{fdc_shared_kernel-0.0.6 → fdc_shared_kernel-0.0.9}/src/shared_kernel/security/key_vault/aws_secret_manager.py

@@ -1,7 +1,7 @@
 import boto3
+import logging
 from botocore.exceptions import ClientError
 from shared_kernel.interfaces import KeyVaultInterface
-from shared_kernel.logger import Logger
 
 
 class AWSSecretsManager(KeyVaultInterface):
@@ -29,8 +29,7 @@ class AWSSecretsManager(KeyVaultInterface):
                                     aws_access_key_id=self._aws_access_key_id,
                                     aws_secret_access_key=self._aws_secret_access_key,
                                     region_name=self._region_name)
-        self.logger = Logger('SHARED_KERNEL')
-        self.logger.info(f"Connected to AWS Secrets Manager in region: {self._region_name}")
+        logging.info(f"Connected to AWS Secrets Manager in region: {self._region_name}")
 
     def store_secret(self, name: str, secret: str) -> None:
         """
@@ -45,13 +44,13 @@ class AWSSecretsManager(KeyVaultInterface):
         """
         try:
             self._client.create_secret(Name=name, SecretString=secret)
-            self.logger.info(f"Stored secret '{name}'")
+            logging.info(f"Stored secret '{name}'")
         except ClientError as e:
             if e.response['Error']['Code'] == 'ResourceExistsException':
                 self._client.update_secret(SecretId=name, SecretString=secret)
-                self.logger.info(f"Updated secret '{name}'")
+                logging.info(f"Updated secret '{name}'")
             else:
-                self.logger.error(f"Failed to update secret '{name}' | Error: '{e}'")
+                logging.error(f"Failed to update secret '{name}' | Error: '{e}'")
                 raise e
 
     def retrieve_secret(self, name: str) -> str:
@@ -71,7 +70,7 @@ class AWSSecretsManager(KeyVaultInterface):
             response = self._client.get_secret_value(SecretId=name)
             return response['SecretString']
         except ClientError as e:
-            self.logger.error(f"Error retrieving secret '{name}': {e}")
+            logging.error(f"Error retrieving secret '{name}': {e}")
             return None
 
     def delete_secret(self, name: str) -> None:
@@ -86,9 +85,9 @@ class AWSSecretsManager(KeyVaultInterface):
         """
         try:
             self._client.delete_secret(SecretId=name, ForceDeleteWithoutRecovery=True)
-            self.logger.info(f"Deleted secret '{name}'")
+            logging.info(f"Deleted secret '{name}'")
         except ClientError as e:
-            self.logger.error(f"Error deleting secret '{name}': {e}")
+            logging.error(f"Error deleting secret '{name}': {e}")
 
     def list_secrets(self) -> list:
         """
@@ -104,5 +103,5 @@ class AWSSecretsManager(KeyVaultInterface):
             response = self._client.list_secrets()
             return [secret['Name'] for secret in response['SecretList']]
         except ClientError as e:
-            self.logger.error(f"Error listing secrets: {e}")
+            logging.error(f"Error listing secrets: {e}")
             return []

{fdc_shared_kernel-0.0.6 → fdc_shared_kernel-0.0.9}/src/shared_kernel/security/key_vault/azure_keyvault.py

@@ -1,7 +1,7 @@
 from azure.identity import ClientSecretCredential
 from azure.keyvault.secrets import SecretClient
 from shared_kernel.interfaces import KeyVaultInterface
-from shared_kernel.logger import Logger
+import logging
 
 
 class AzureKeyVault(KeyVaultInterface):
@@ -38,8 +38,7 @@ class AzureKeyVault(KeyVaultInterface):
             client_secret=config.get('client_secret')
         )
         self._client = SecretClient(vault_url=self._vault_url, credential=self._credential)
-        self.logger = Logger('SHARED_KERNEL')
-        self.logger.info(f"Connected to Azure Key Vault at: {self._vault_url}")
+        logging.info(f"Connected to Azure Key Vault at: {self._vault_url}")
 
     def store_secret(self, name: str, secret: str) -> None:
         """
@@ -50,7 +49,7 @@ class AzureKeyVault(KeyVaultInterface):
             secret (str): The value of the secret.
         """
         self._client.set_secret(name, secret)
-        self.logger.info(f"Stored secret '{name}'")
+        logging.info(f"Stored secret '{name}'")
 
     def retrieve_secret(self, name: str) -> str:
         """
@@ -73,7 +72,7 @@ class AzureKeyVault(KeyVaultInterface):
             name (str): The name of the secret.
         """
         self._client.begin_delete_secret(name)
-        self.logger.info(f"Deleted secret '{name}'")
+        logging.info(f"Deleted secret '{name}'")
 
     def list_secrets(self) -> list:
         """

fdc_shared_kernel-0.0.6/src/shared_kernel/exceptions/http_exceptions.py

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