bb-integrations-library 3.0.11__py3-none-any.whl

bb_integrations_lib/util/config/manager.py

@@ -0,0 +1,391 @@
+import json
+from loguru import logger
+from typing import Dict, Optional, Any
+
+from bb_integrations_lib.mappers.prices.protocol import PriceMapperProtocol
+from bb_integrations_lib.shared.model import File
+from bb_integrations_lib.util.config.model import GlobalConfig, Configs, Config, ClientConstructor, Client
+from bb_integrations_lib.provider.gcp.cloud_secrets.client import CloudSecretsClient
+
+
+# Base Exception class for GlobalConfigManager
+class GlobalConfigException(Exception):
+    """Base exception class for GlobalConfigManager operations."""
+    pass
+
+
+# Environment-related exceptions
+class EnvironmentException(GlobalConfigException):
+    """Base exception class for environment-related operations."""
+    pass
+
+
+class EnvironmentAlreadyExistsException(EnvironmentException):
+    """Raised when trying to create an environment that already exists."""
+    pass
+
+
+class EnvironmentDoesNotExistException(EnvironmentException):
+    """Raised when trying to access an environment that does not exist."""
+    pass
+
+
+# Config-related exceptions
+class ConfigException(GlobalConfigException):
+    """Base exception class for configuration-related operations."""
+    pass
+
+
+class ConfigAlreadyExistsException(ConfigException):
+    """Raised when trying to create a config that already exists."""
+    pass
+
+
+class ConfigDoesNotExistException(ConfigException):
+    """Raised when trying to access a config that does not exist."""
+    pass
+
+
+class GlobalConfigManager:
+    """Manages global configurations for clients/customers stored in Google Cloud Secret Manager.
+
+    This class provides an interface to create, retrieve, update, and delete
+    client-specific configuration data in a centralized location. Each client
+    (referred to as an "environment") has its own dedicated configuration space
+    within a single Google Cloud Secret.
+
+    All environment names are automatically converted to lowercase for consistency.
+    """
+
+    def __init__(self, file_name_override: Optional[str] = None):
+        """Initialize the manager with a file name.
+
+        Args:
+            file_name_override: Custom file name for the configuration.
+                Defaults to "global_integration_configurations".
+        """
+        self.file_name = file_name_override or "global_integration_configurations"
+
+    def environment_from_name(self, environment_name: str, env_mode: str, sd_basic_auth: bool = False) -> ClientConstructor:
+        from bb_integrations_lib.gravitate.rita_api import GravitateRitaAPI
+        from bb_integrations_lib.gravitate.sd_api import GravitateSDAPI
+        from bb_integrations_lib.gravitate.pe_api import GravitatePEAPI
+        from bb_integrations_lib.util.config.model import GlobalConfig, ClientConstructor, Client
+        environment: GlobalConfig = self.get_environment(environment_name)
+        test_environment = environment.test
+        production_environment = environment.prod
+        if env_mode.lower() in ["development", "test"]:
+            env = test_environment
+        else:
+            env = production_environment
+
+        if sd_basic_auth:
+            sd_api_client = GravitateSDAPI(
+                base_url=env.sd.base_url,
+                username=env.sd.username,
+                password=env.sd.password,
+            )
+        else:
+            sd_api_client = GravitateSDAPI(
+                base_url=env.sd.base_url,
+                client_id=env.sd.client_id,
+                client_secret=env.sd.client_secret,
+            )
+
+        return ClientConstructor(
+            rita=Client(
+                config=env.rita,
+                api_client=GravitateRitaAPI(
+                    tenant=environment_name,
+                    client_id=env.rita.client_id,
+                    client_secret=env.rita.client_secret,
+                )
+            ),
+            sd=Client(
+                config=env.sd,
+                api_client=sd_api_client
+            ),
+            pe=Client(
+                config=env.pe,
+                api_client=GravitatePEAPI(base_url=env.pe.base_url,
+                                          username=env.pe.username,
+                                          password=env.pe.password,
+                                          )
+            )
+
+        )
+
+    def get_secret(self, project_id_override: Optional[str] = None) -> Dict[str, Any]:
+        """Retrieve the entire secret from Cloud Secret Manager.
+
+        Gets the complete configuration containing all client/customer environments.
+
+        Args:
+            project_id_override: Optional project ID to use instead of the default.
+
+        Returns:
+            Dictionary containing the complete secret data with all client configurations.
+
+        Raises:
+            ConfigDoesNotExistException: If the secret does not exist.
+            GlobalConfigException: If there's an error retrieving the secret.
+        """
+        try:
+            secret = CloudSecretsClient.get_file(path=self.file_name, file_name=self.file_name,
+                                                 project_id=project_id_override)
+            if not secret:
+                raise ConfigDoesNotExistException(f"Config file '{self.file_name}' does not exist")
+            data = secret.data
+            return json.loads(data)
+        except ConfigDoesNotExistException:
+            logger.error(f"Config file '{self.file_name}' does not exist")
+            raise
+        except Exception as e:
+            logger.error(f"Failed to retrieve secret {self.file_name}: {str(e)}")
+            raise GlobalConfigException(f"Error retrieving secret: {str(e)}")
+
+    def get_environment(self, environment_name: str, project_id_override: Optional[str] = None) -> GlobalConfig:
+        """Retrieve configuration for a specific client/customer.
+
+        Gets the configuration data for a single environment (client/customer).
+        Environment names are case-insensitive and will be converted to lowercase.
+
+        Args:
+            environment_name: Name of the client/customer environment.
+            project_id_override: Optional project ID to use instead of the default.
+
+        Returns:
+            GlobalConfig object containing the configuration for the specified environment.
+
+        Raises:
+            EnvironmentDoesNotExistException: If the environment does not exist.
+            GlobalConfigException: If there's an error retrieving the secret.
+        """
+        environment_name = environment_name.lower()
+        try:
+            secret = self.get_secret(project_id_override)
+            if environment_name not in secret:
+                raise EnvironmentDoesNotExistException(f"Environment '{environment_name}' does not exist")
+            return GlobalConfig.model_validate(secret[environment_name])
+        except ConfigDoesNotExistException:
+            raise
+        except EnvironmentDoesNotExistException:
+            logger.error(f"Environment '{environment_name}' does not exist")
+            raise
+        except Exception as e:
+            logger.error(f"Error getting environment '{environment_name}': {str(e)}")
+            raise GlobalConfigException(f"Error retrieving environment '{environment_name}': {str(e)}")
+
+    def dict_has_attribute(self, dictionary: Dict, attribute_name: str) -> bool:
+        """Check if a dictionary has a specific key.
+
+        Performs a case-insensitive check by converting the attribute name to lowercase.
+
+        Args:
+            dictionary: The dictionary to check.
+            attribute_name: The key name to look for.
+
+        Returns:
+            True if the key exists, False otherwise.
+        """
+        attribute_name = attribute_name.lower()
+        return attribute_name in dictionary
+
+    def create_new_config(self, config: Dict[str, Any], project_id_override: Optional[str] = None):
+        """Create a completely new configuration, replacing the entire secret.
+
+        Use with caution as this replaces all existing client configurations.
+
+        Args:
+            config: Complete configuration dictionary to store.
+            project_id_override: Optional project ID to use instead of the default.
+
+        Raises:
+            GlobalConfigException: If there's an error uploading the configuration.
+        """
+        try:
+            self._upload_config(config_data=config, project_id_override=project_id_override)
+        except Exception as e:
+            logger.error(f"Failed to create new config: {str(e)}")
+            raise GlobalConfigException(f"Failed to create new config: {str(e)}")
+
+    def create_new_environment(self, environment_name: str, config: GlobalConfig,
+                               project_id_override: Optional[str] = None) -> None:
+        """Create a new configuration for a client/customer.
+
+        Adds a new client-specific configuration to the existing secret.
+        Environment names are case-insensitive and will be converted to lowercase.
+
+        Args:
+            environment_name: Name of the client/customer environment.
+            config: Configuration object to store.
+            project_id_override: Optional project ID to use instead of the default.
+
+        Raises:
+            EnvironmentAlreadyExistsException: If an environment with the given name already exists.
+            GlobalConfigException: For any other errors during creation.
+        """
+        environment_name = environment_name.lower()
+        try:
+            secret_dict = self.get_secret(project_id_override=project_id_override)
+            if self.dict_has_attribute(secret_dict, environment_name):
+                raise EnvironmentAlreadyExistsException(f"Environment '{environment_name}' already exists")
+            secret_dict[environment_name] = config.model_dump()
+            self._upload_config(secret_dict)
+        except EnvironmentAlreadyExistsException:
+            logger.error(f"Environment '{environment_name}' already exists")
+            raise
+        except ConfigDoesNotExistException:
+            # If the config doesn't exist yet, create a new one with just this environment
+            try:
+                new_config = {environment_name: config.model_dump()}
+                self._upload_config(new_config, project_id_override)
+            except Exception as e:
+                logger.error(f"Failed to create new environment '{environment_name}': {str(e)}")
+                raise GlobalConfigException(f"Failed to create new environment '{environment_name}': {str(e)}")
+        except Exception as e:
+            logger.error(f"Failed to create new environment '{environment_name}': {str(e)}")
+            raise GlobalConfigException(f"Failed to create new environment '{environment_name}': {str(e)}")
+
+    def overwrite_config(self, environment_name: str, config: GlobalConfig,
+                         project_id_override: Optional[str] = None) -> None:
+        """Overwrite an existing client/customer configuration.
+
+        Updates the configuration for an existing environment.
+        Environment names are case-insensitive and will be converted to lowercase.
+
+        Args:
+            environment_name: Name of the client/customer environment to update.
+            config: New configuration object.
+            project_id_override: Optional project ID to use instead of the default.
+
+        Raises:
+            EnvironmentDoesNotExistException: If the specified environment doesn't exist.
+            GlobalConfigException: For any other errors during update.
+        """
+        environment_name = environment_name.lower()
+        try:
+            secret_dict = self.get_secret(project_id_override=project_id_override)
+            if not self.dict_has_attribute(secret_dict, environment_name):
+                raise EnvironmentDoesNotExistException(f"Environment '{environment_name}' does not exist")
+            secret_dict[environment_name] = config.model_dump()
+            self._upload_config(secret_dict)
+        except EnvironmentDoesNotExistException:
+            logger.error(f"Environment '{environment_name}' does not exist")
+            raise
+        except Exception as e:
+            logger.error(f"Failed to overwrite environment '{environment_name}': {str(e)}")
+            raise GlobalConfigException(f"Failed to overwrite environment '{environment_name}': {str(e)}")
+
+    def delete_config(self, environment_name: str, project_id_override: Optional[str] = None) -> None:
+        """Delete a configuration for a client/customer.
+
+        Removes a client-specific configuration from the secret.
+        Environment names are case-insensitive and will be converted to lowercase.
+
+        Args:
+            environment_name: Name of the client/customer environment to delete.
+            project_id_override: Optional project ID to use instead of the default.
+
+        Raises:
+            EnvironmentDoesNotExistException: If the specified environment doesn't exist.
+            GlobalConfigException: For any other errors during deletion.
+        """
+        environment_name = environment_name.lower()
+        try:
+            secret_dict = self.get_secret(project_id_override=project_id_override)
+            if not self.dict_has_attribute(secret_dict, environment_name):
+                raise EnvironmentDoesNotExistException(f"Environment '{environment_name}' does not exist")
+            del secret_dict[environment_name]
+            self._upload_config(secret_dict)
+        except EnvironmentDoesNotExistException:
+            logger.error(f"Environment '{environment_name}' does not exist")
+            raise
+        except Exception as e:
+            logger.error(f"Failed to delete environment '{environment_name}': {str(e)}")
+            raise GlobalConfigException(f"Failed to delete environment '{environment_name}': {str(e)}")
+
+    def _upload_config(self, config_data: Dict[str, Any], project_id_override: Optional[str] = None) -> None:
+        """Helper method to upload configuration to Cloud Secret Manager.
+
+        Handles the serialization and upload of configuration data to the secret.
+        Keep in mind that Google Cloud Secret Manager has a 64 KiB size limitation.
+
+        Args:
+            config_data: Configuration data to upload.
+            project_id_override: Optional project ID to use instead of the default.
+
+        Raises:
+            GlobalConfigException: If there's an error uploading the configuration.
+        """
+        try:
+            file = File(file_name=self.file_name, file_data=config_data, project_id=project_id_override)
+            CloudSecretsClient.upload_file(path="", file=file)
+            logger.info(f"Successfully updated configuration '{self.file_name}'")
+        except Exception as e:
+            logger.error(f"Failed to upload configuration '{self.file_name}': {str(e)}")
+            raise GlobalConfigException(f"Failed to upload configuration: {str(e)}")
+
+
+if __name__ == "__main__":
+    gg = GlobalConfigManager()
+    dd = gg.environment_from_name("Loves", "test")
+    print(dd)
+    config = GlobalConfig(
+        prod=Configs(
+            rita=Config(
+                client_id=None,
+                client_secret=None,
+                psk=None,
+                username=None,
+                password=None,
+                base_url=None,
+            ),
+            sd=Config(
+                client_id=None,
+                client_secret=None,
+                psk=None,
+                username=None,
+                password=None,
+                base_url=None,
+            ),
+            pe=Config(
+                client_id=None,
+                client_secret=None,
+                psk=None,
+                username=None,
+                password=None,
+                base_url=None,
+            )
+        ),
+        test=Configs(
+            rita=Config(
+                client_id=None,
+                client_secret=None,
+                psk=None,
+                username=None,
+                password=None,
+                base_url=None,
+            ),
+            sd=Config(
+                client_id=None,
+                client_secret=None,
+                psk=None,
+                username=None,
+                password=None,
+                base_url=None,
+            ),
+            pe=Config(
+                client_id=None,
+                client_secret=None,
+                psk=None,
+                username=None,
+                password=None,
+                base_url=None,
+            )
+        ),
+        extra_data={
+            "name": "loves"
+        }
+    )
+    # gg.create_new_environment(environment_name="loves", config=config)

bb_integrations_lib/util/config/model.py

@@ -0,0 +1,41 @@
+from typing import Optional, Dict
+
+from bb_integrations_lib.gravitate.base_api import BaseAPI
+from pydantic import BaseModel, Field, ConfigDict
+
+
+class Config(BaseModel):
+    client_id: Optional[str] = None
+    client_secret: Optional[str] = None
+    psk: Optional[str] = None
+    username: Optional[str] = None
+    password: Optional[str] = None
+    base_url: Optional[str] = None
+    mongo_conn_str: Optional[str] = None
+    mongo_db_name: Optional[str] = None
+    extra_data: Optional[Dict] = Field(default_factory=dict)
+
+
+class Configs(BaseModel):
+    rita: Optional[Config] = Field(default_factory=Config)
+    sd: Optional[Config] = Field(default_factory=Config)
+    pe: Optional[Config] = Field(default_factory=Config)
+    crossroads: Optional[Config] = Field(default_factory=Config)
+
+
+class GlobalConfig(BaseModel):
+    prod: Configs = Field(default_factory=Configs)
+    test: Configs = Field(default_factory=Configs)
+    extra_data: Optional[Dict] = Field(default_factory=dict)
+
+
+class Client(BaseModel):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    config: Config
+    api_client: BaseAPI
+
+
+class ClientConstructor(BaseModel):
+    rita:Client
+    sd: Client
+    pe: Client

bb_integrations_lib/util/exception_logger/exception_logger.py

@@ -0,0 +1,146 @@
+import functools
+import traceback
+from typing import Dict, Any, Callable, Optional
+import json
+from datetime import datetime
+
+
+class ExceptionLogger:
+    """
+    A class that provides a decorator for catching and logging exceptions.
+    """
+
+    def __init__(self):
+        """Initialize a new exception logger with an empty log."""
+        self._exception_log: Dict[str, Any] = {}
+
+    def catch_exceptions(self, identifier_param: Optional[str] = None):
+        """
+        Decorator that catches exceptions and logs them to this logger's dictionary.
+
+        Args:
+            identifier_param (str, optional): The parameter name to use as the identifier in the log.
+                                             If None, will use function name + args as identifier.
+        """
+
+        def decorator(func: Callable) -> Callable:
+            @functools.wraps(func)
+            def wrapper(*args, **kwargs):
+                # Determine the identifier
+                identifier = self._get_identifier(func, args, kwargs, identifier_param)
+
+                try:
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    # Log the exception
+                    self._exception_log[identifier] = {
+                        'timestamp': datetime.now().isoformat(),
+                        'exception_type': type(e).__name__,
+                        'exception_message': str(e),
+                        'traceback': traceback.format_exc(),
+                        'function': func.__name__,
+                        'args': self._safe_repr(args),
+                        'kwargs': self._safe_repr(kwargs)
+                    }
+                    # Re-raise the exception
+                    raise
+
+            return wrapper
+
+        return decorator
+
+    def _get_identifier(self, func: Callable, args: tuple, kwargs: dict, identifier_param: Optional[str]) -> str:
+        """
+        Get an identifier for the function call based on the provided parameters.
+
+        Args:
+            func: The function being called
+            args: Positional arguments
+            kwargs: Keyword arguments
+            identifier_param: Parameter name to use as identifier
+
+        Returns:
+            str: An identifier for this function call
+        """
+        if identifier_param and identifier_param in kwargs:
+            return str(kwargs[identifier_param])
+
+        if identifier_param and args:
+            # Try to find the position of the identifier parameter
+            try:
+                param_names = func.__code__.co_varnames[:func.__code__.co_argcount]
+                if identifier_param in param_names:
+                    idx = param_names.index(identifier_param)
+                    if idx < len(args):
+                        return str(args[idx])
+            except (AttributeError, IndexError):
+                pass
+
+        # Generate a unique identifier using function name and a hash of arguments
+        arg_str = self._safe_repr(args)
+        kwarg_str = self._safe_repr(kwargs)
+        return f"{func.__name__}_{hash(arg_str + kwarg_str)}_{datetime.now().timestamp()}"
+
+    def _safe_repr(self, obj: Any) -> str:
+        """
+        Create a safe string representation of an object.
+
+        Args:
+            obj: The object to represent
+
+        Returns:
+            str: A string representation of the object
+        """
+        try:
+            return str(obj)
+        except Exception:
+            return f"<unprintable object of type {type(obj).__name__}>"
+
+    def get_log(self) -> Dict[str, Any]:
+        """
+        Get the current exception log.
+
+        Returns:
+            Dict[str, Any]: The exception log
+        """
+        return self._exception_log.copy()
+
+    def clear_log(self) -> None:
+        """Clear the exception log."""
+        self._exception_log.clear()
+
+    def get_formatted_log(self, indent: int = 2) -> str:
+        """
+        Get the exception log formatted as JSON.
+
+        Args:
+            indent (int): Number of spaces for JSON indentation
+
+        Returns:
+            str: Formatted JSON string
+        """
+        return json.dumps(self._exception_log, indent=indent)
+
+    def get_exception_count(self) -> int:
+        """
+        Get the number of exceptions logged.
+
+        Returns:
+            int: Number of exceptions
+        """
+        return len(self._exception_log)
+
+    def get_exceptions_by_type(self) -> Dict[str, int]:
+        """
+        Get a count of exceptions grouped by exception type.
+
+        Returns:
+            Dict[str, int]: Counts of each exception type
+        """
+        counts: Dict[str, int] = {}
+        for exc_info in self._exception_log.values():
+            exc_type = exc_info.get('exception_type', 'Unknown')
+            counts[exc_type] = counts.get(exc_type, 0) + 1
+        return counts
+
+

bb_integrations_lib/util/exception_logger/test.py

@@ -0,0 +1,114 @@
+from exception_logger import ExceptionLogger
+
+# Create a logger instance
+logger = ExceptionLogger()
+
+
+# Example class using the exception logger
+class DataProcessor:
+    def __init__(self, logger):
+        self.logger = logger
+        self.processed_count = 0
+
+    @logger.catch_exceptions(identifier_param='record_id')
+    def process_record(self, record_id, data):
+        """Process a single data record"""
+        if not data:
+            raise ValueError(f"No data provided for record {record_id}")
+
+        if 'amount' not in data:
+            raise KeyError(f"Missing required field 'amount' in record {record_id}")
+
+        # Process the record
+        result = data['amount'] * 2
+        self.processed_count += 1
+        return result
+
+
+# Multiple loggers for different components
+api_logger = ExceptionLogger()
+db_logger = ExceptionLogger()
+
+
+# Example API function using a different logger
+@api_logger.catch_exceptions()
+def api_request(endpoint, payload=None):
+    if not endpoint:
+        raise ValueError("Endpoint cannot be empty")
+
+    if endpoint == "/error":
+        raise ConnectionError("Simulated API error")
+
+    return {"status": "success", "data": payload}
+
+
+# Example database function using yet another logger
+@db_logger.catch_exceptions(identifier_param='query_id')
+def execute_query(query_id, sql, parameters=None):
+    if not sql:
+        raise ValueError("SQL query cannot be empty")
+
+    if "DROP TABLE" in sql.upper():
+        raise PermissionError("DROP TABLE operations are not allowed")
+
+    return [{"id": 1, "name": "Example"}]
+
+
+# Main demonstration
+def main():
+    print("=== Data Processing Example ===")
+    processor = DataProcessor(logger)
+    records = [
+        {'id': '001', 'data': {'amount': 100}},
+        {'id': '002', 'data': {}},  # Missing 'amount' field
+        {'id': '003', 'data': None},  # None data
+        {'id': '004', 'data': {'amount': 200}}
+    ]
+
+    # Process each record and handle exceptions
+    for record in records:
+        try:
+            result = processor.process_record(record['id'], record['data'])
+            print(f"Record {record['id']} processed successfully: {result}")
+        except Exception as e:
+            print(f"Error processing record {record['id']}: {e}")
+
+    print("\n=== API Example ===")
+    endpoints = ["/users", "/error", ""]
+    for endpoint in endpoints:
+        try:
+            result = api_request(endpoint, {"user": "test"})
+            print(f"API request to {endpoint} succeeded: {result}")
+        except Exception as e:
+            print(f"API request to {endpoint} failed: {e}")
+
+    print("\n=== Database Example ===")
+    queries = [
+        ("Q1", "SELECT * FROM users", None),
+        ("Q2", "", None),  # Empty query
+        ("Q3", "DROP TABLE users", None)  # Not allowed
+    ]
+
+    for query_id, sql, params in queries:
+        try:
+            result = execute_query(query_id, sql, params)
+            print(f"Query {query_id} executed successfully: {result}")
+        except Exception as e:
+            print(f"Query {query_id} failed: {e}")
+
+    # Print summary information
+    print("\n=== Exception Logs ===")
+    print("Data Processing Exceptions:", logger.get_exception_count())
+    print("Exception Types:", logger.get_exceptions_by_type())
+    print("\nAPI Exceptions:", api_logger.get_exception_count())
+    print("Exception Types:", api_logger.get_exceptions_by_type())
+    print("\nDatabase Exceptions:", db_logger.get_exception_count())
+    print("Exception Types:", db_logger.get_exceptions_by_type())
+
+    # Print detailed logs
+    print("\n=== Detailed Data Processing Exception Log ===")
+    print(logger.get_formatted_log())
+
+
+if __name__ == "__main__":
+    main()