trovesuite 1.0.24__py3-none-any.whl → 1.0.31__py3-none-any.whl

trovesuite/__init__.py

@@ -11,7 +11,7 @@ from .notification import NotificationService
 from .storage import StorageService
 from .utils import Helper
 
-__version__ = "1.0.20"
+__version__ = "1.0.29"
 __author__ = "Bright Debrah Owusu"
 __email__ = "owusu.debrah@deladetech.com"
 

trovesuite/configs/database.py

@@ -1,28 +1,49 @@
 """
 Database configuration and connection management
+
+FIXED VERSION - Removed pool reinitialization during runtime to prevent "unkeyed connection" errors.
+Key changes:
+- Pool created once at startup, never recreated during runtime
+- Removed connection validation queries that consume pool connections
+- Increased default pool size to 2 (safe for Azure Basic tier)
+- Simplified get_db_connection() - let pool.getconn() block naturally
+- Removed _recover_connection_pool() and _is_pool_valid() runtime checks
+
+NOTE: Database initialization is NOT automatic for package version.
+You must call initialize_database() explicitly in your application startup.
+Example in FastAPI:
+    @app.on_event("startup")
+    async def startup_event():
+        initialize_database()
 """
 from contextlib import contextmanager
 from typing import Generator, Optional
 import psycopg2
 import psycopg2.pool
 from psycopg2.extras import RealDictCursor
+import threading
 from .settings import db_settings
 from .logging import get_logger
 
 logger = get_logger("database")
 
-# Database connection pool
+# Database connection pool - created once at startup, never replaced during runtime
 _connection_pool: Optional[psycopg2.pool.ThreadedConnectionPool] = None
+_initialization_lock = threading.Lock()
 
 
 class DatabaseConfig:
     """Database configuration and connection management"""
 
     def __init__(self):
+        import os
         self.settings = db_settings
         self.database_url = self.settings.database_url
-        self.pool_size = 5
-        self.max_overflow = 10
+        # Safe pool size for Azure Basic tier (B_Standard_B1ms)
+        # With 2 workers and pool_size=2: 2 × 2 = 4 connections (very safe)
+        # With 4 workers and pool_size=2: 4 × 2 = 8 connections (still safe, well under 50 limit)
+        # Can be overridden with DB_POOL_SIZE environment variable
+        self.pool_size = int(os.getenv("DB_POOL_SIZE", "2"))
 
     def get_connection_params(self) -> dict:
         """Get database connection parameters"""
@@ -35,7 +56,7 @@ class DatabaseConfig:
                 "keepalives_idle": 30,
                 "keepalives_interval": 10,
                 "keepalives_count": 5,
-                "connect_timeout": 10
+                "connect_timeout": 30  # Increased timeout for Azure PostgreSQL
             }
 
         # fallback to individual DB_* variables
@@ -57,19 +78,43 @@ class DatabaseConfig:
     def create_connection_pool(self) -> psycopg2.pool.ThreadedConnectionPool:
         """Create a connection pool for psycopg2"""
         try:
+            import os
+            dsn = os.getenv("DATABASE_URL", "") or str(self.database_url or "")
+            is_azure = "database.azure.com" in dsn.lower()
+            pool_size = self.pool_size
+            
             pool = psycopg2.pool.ThreadedConnectionPool(
                 minconn=1,
-                maxconn=self.pool_size,
+                maxconn=pool_size,
                 **self.get_connection_params()
             )
-            logger.info(f"Database connection pool created with {self.pool_size} connections")
+            logger.info(
+                f"Database connection pool created with {pool_size} connections "
+                f"(Azure: {is_azure}, DB_POOL_SIZE: {self.pool_size})"
+            )
             return pool
+        except psycopg2.OperationalError as e:
+            error_str = str(e).lower()
+            if any(keyword in error_str for keyword in ["connection", "slot", "limit", "exhausted", "too many"]):
+                logger.error("⚠️  Database connection limit reached!")
+                logger.error("   Possible causes:")
+                logger.error("   1. Too many connections from multiple replicas/workers")
+                logger.error("   2. Pool size too high (DB_POOL_SIZE environment variable)")
+                logger.error("   3. Too many Gunicorn workers (GUNICORN_WORKERS environment variable)")
+                logger.error("   4. Connections not being properly returned to pool")
+                logger.error("   Solutions:")
+                logger.error("   - Set DB_POOL_SIZE=2 (current default)")
+                logger.error("   - Reduce GUNICORN_WORKERS (default: 4)")
+                logger.error("   - Consider using PgBouncer for connection pooling")
+                logger.error("   - Upgrade to a higher PostgreSQL tier if needed")
+            logger.error(f"Failed to create database connection pool: {str(e)}")
+            raise
         except Exception as e:
             logger.error(f"Failed to create database connection pool: {str(e)}")
             raise
 
     def test_connection(self) -> bool:
-        """Test database connection"""
+        """Test database connection (only used at startup)"""
         try:
             with psycopg2.connect(**self.get_connection_params()) as conn:
                 with conn.cursor() as cursor:
@@ -89,89 +134,104 @@ db_config = DatabaseConfig()
 
 
 def initialize_database():
-    """Initialize database connections and pool"""
+    """
+    Initialize database connections and pool.
+    This should ONLY be called at application startup.
+    Pool is created once and never recreated during runtime.
+    
+    NOTE: For package version, this must be called explicitly in application startup.
+    """
     global _connection_pool
+    
+    with _initialization_lock:
+        # If pool already exists, don't recreate it
+        if _connection_pool is not None:
+            logger.warning("Database pool already initialized, skipping reinitialization")
+            return
+        
+        try:
+            # Test connection first (only at startup)
+            if not db_config.test_connection():
+                raise Exception("Database connection test failed")
 
-    try:
-        # Test connection first
-        if not db_config.test_connection():
-            raise Exception("Database connection test failed")
-
-        # Create connection pool
-        _connection_pool = db_config.create_connection_pool()
+            # Create connection pool (only once at startup)
+            _connection_pool = db_config.create_connection_pool()
+            
+            # Verify pool was created successfully
+            if _connection_pool is None:
+                raise Exception("Connection pool creation returned None")
 
-        logger.info("Database initialization completed successfully")
+            logger.info("✅ Database initialization completed successfully")
 
-    except Exception as e:
-        logger.error(f"Database initialization failed: {str(e)}")
-        raise
+        except Exception as e:
+            logger.error(f"❌ Database initialization failed: {str(e)}")
+            _connection_pool = None  # Ensure pool is None on failure
+            raise
 
 
 def get_connection_pool() -> psycopg2.pool.ThreadedConnectionPool:
-    """Get the database connection pool"""
+    """
+    Get the database connection pool.
+    Pool must be initialized at startup. This function will raise if pool is None.
+    """
     global _connection_pool
+    
     if _connection_pool is None:
         error_msg = (
-            "Database not initialized. This usually means:\n"
-            "1. Missing or incorrect .env file in app/ directory\n"
-            "2. Database credentials are wrong\n"
-            "3. Database container is not running\n"
-            "4. Database initialization failed during startup\n"
-            "Please check the startup logs for more details."
+            "Database connection pool is not initialized. "
+            "Please ensure initialize_database() was called at application startup."
         )
         logger.error(error_msg)
         raise Exception(error_msg)
+    
     return _connection_pool
 
 
-def _validate_connection(conn) -> bool:
-    """Validate if a connection is still alive"""
-    try:
-        # Test if connection is alive with a simple query
-        with conn.cursor() as cursor:
-            cursor.execute("SELECT 1")
-        return True
-    except (psycopg2.OperationalError, psycopg2.InterfaceError):
-        return False
-
-
 @contextmanager
 def get_db_connection():
-    """Get a database connection from the pool (context manager)"""
+    """
+    Get a database connection from the pool (context manager).
+    
+    This is simplified - we let pool.getconn() block naturally.
+    No retries, no validation queries, no pool recovery.
+    """
     pool = get_connection_pool()
     conn = None
     try:
+        # Get connection from pool - this will block if pool is exhausted
+        # That's the correct behavior - let backpressure happen naturally
         conn = pool.getconn()
-
-        # Validate connection before using it
-        if not _validate_connection(conn):
-            logger.warning("Stale connection detected, getting new connection")
-            pool.putconn(conn, close=True)
-            conn = pool.getconn()
-
         logger.debug("Database connection acquired from pool")
         yield conn
     except Exception as e:
-        logger.error(f"Database connection error: {str(e)}")
-        if conn:
+        # If connection exists and isn't closed, rollback transaction
+        if conn and not conn.closed:
             try:
-                # Only rollback if connection is still open
-                if not conn.closed:
-                    conn.rollback()
-            except (psycopg2.OperationalError, psycopg2.InterfaceError) as rollback_error:
-                logger.warning(f"Could not rollback closed connection: {str(rollback_error)}")
+                conn.rollback()
+            except Exception as rollback_error:
+                logger.warning(f"Could not rollback transaction: {str(rollback_error)}")
+        # Re-raise the exception - don't retry here
         raise
     finally:
+        # Always return connection to pool
         if conn:
             try:
-                # If connection is broken, close it instead of returning to pool
                 if conn.closed:
+                    # If connection is closed, tell pool to close it instead of returning
                     pool.putconn(conn, close=True)
                 else:
+                    # Return connection to pool normally
                     pool.putconn(conn)
                 logger.debug("Database connection returned to pool")
             except Exception as put_error:
+                # Log error but don't fail - connection will be cleaned up by pool
                 logger.error(f"Error returning connection to pool: {str(put_error)}")
+                # Try to close connection manually as last resort
+                try:
+                    if not conn.closed:
+                        conn.close()
+                except Exception:
+                    pass
 
 
 @contextmanager
@@ -244,6 +304,7 @@ class DatabaseManager:
                 cursor.execute("INSERT INTO table2 ...")
                 # Auto-commits on success, auto-rollbacks on exception
         """
+        # Use get_db_connection() instead of directly accessing pool
         with get_db_connection() as conn:
             cursor = conn.cursor(cursor_factory=RealDictCursor)
             try:
@@ -267,7 +328,10 @@ class DatabaseManager:
 
     @staticmethod
     def health_check() -> dict:
-        """Perform database health check"""
+        """
+        Perform database health check.
+        Health checks are allowed to fail - they don't attempt to repair the pool.
+        """
         try:
             with get_db_cursor() as cursor:
                 cursor.execute("SELECT version(), current_database(), current_user")
@@ -303,13 +367,9 @@ class DatabaseManager:
             }
 
 
-# Database initialization on module import
-try:
-    initialize_database()
-except Exception as e:
-    logger.error(f"Failed to initialize database on startup: {str(e)}")
-    logger.error("⚠️  CRITICAL: Application started without database connection!")
-    logger.error("⚠️  Please check your .env file and database configuration")
-    logger.error("⚠️  The application will not function properly without a database connection")
-    # Don't raise here to allow the app to start even if DB is unavailable
-    # But log it clearly so it's obvious what's wrong
+# NOTE: Database initialization is NOT automatic for package version
+# You must call initialize_database() explicitly in your application startup
+# Example in FastAPI:
+#   @app.on_event("startup")
+#   async def startup_event():
+#       initialize_database()

trovesuite/configs/settings.py

@@ -10,11 +10,6 @@ class Settings:
     DB_PORT: str = os.getenv("DB_PORT")
     DB_PASSWORD: str = os.getenv("DB_PASSWORD")
     
-    # CORS Endpoint
-    # LOCAL_HOST_URL = os.getenv("LOCAL_HOST_URL")
-    # FRONTEND_SERVER_URL_1 = os.getenv("FRONTEND_SERVER_URL")
-    # FRONTEND_SERVER_URL_2 = os.getenv("FRONTEND_SERVER_URL")
-
     # Application settings
     DEBUG: bool = os.getenv("DEBUG", "True").lower() in ("true",1)
     APP_NAME: str = os.getenv("APP_NAME", "Python Template API")
@@ -38,13 +33,11 @@ class Settings:
     # SHARED TABLES (core_platform schema)
     # =============================================================================
     CORE_PLATFORM_TENANTS_TABLE = os.getenv("CORE_PLATFORM_TENANTS_TABLE", "core_platform.cp_tenants")
-    CORE_PLATFORM_TENANT_RESOURCE_ID_TABLE = os.getenv("CORE_PLATFORM_TENANT_RESOURCE_ID_TABLE", "core_platform.cp_resource_ids")
     CORE_PLATFORM_SUBSCRIPTIONS_TABLE = os.getenv("CORE_PLATFORM_SUBSCRIPTIONS_TABLE", "core_platform.cp_subscriptions")
     CORE_PLATFORM_APPS_TABLE = os.getenv("CORE_PLATFORM_APPS_TABLE", "core_platform.cp_apps")
     CORE_PLATFORM_USERS_TABLE = os.getenv("CORE_PLATFORM_USERS_TABLE", "core_platform.cp_users")
     CORE_PLATFORM_RESOURCE_TYPES_TABLE = os.getenv("CORE_PLATFORM_RESOURCE_TYPES_TABLE", "core_platform.cp_resource_types")
-    CORE_PLATFORM_RESOURCE_ID_TABLE = os.getenv("CORE_PLATFORM_RESOURCE_ID_TABLE", "core_platform.cp_shared_resource_ids")
-    CORE_PLATFORM_RESOURCES_TABLE = os.getenv("CORE_PLATFORM_RESOURCES_TABLE", "core_platform.resources")
+    CORE_PLATFORM_RESOURCE_ID_TABLE = os.getenv("CORE_PLATFORM_RESOURCE_ID_TABLE", "core_platform.cp_resource_ids")
     CORE_PLATFORM_PERMISSIONS_TABLE = os.getenv("CORE_PLATFORM_PERMISSIONS_TABLE", "core_platform.cp_permissions")
     CORE_PLATFORM_ROLES_TABLE = os.getenv("CORE_PLATFORM_ROLES_TABLE", "core_platform.cp_roles")
     CORE_PLATFORM_ROLE_PERMISSIONS_TABLE = os.getenv("CORE_PLATFORM_ROLE_PERMISSIONS_TABLE", "core_platform.cp_role_permissions")
@@ -69,7 +62,6 @@ class Settings:
     CORE_PLATFORM_LOGIN_SETTINGS_TABLE = os.getenv("CORE_PLATFORM_LOGIN_SETTINGS_TABLE", "core_platform.cp_login_settings")
     CORE_PLATFORM_RESOURCES_TABLE = os.getenv("CORE_PLATFORM_RESOURCES_TABLE", "core_platform.cp_resources")
     CORE_PLATFORM_ASSIGN_ROLES_TABLE = os.getenv("CORE_PLATFORM_ASSIGN_ROLES_TABLE", "core_platform.cp_assign_roles")
-    CORE_PLATFORM_RESOURCE_ID_TABLE = os.getenv("CORE_PLATFORM_RESOURCE_ID_TABLE", "core_platform.cp_resource_ids")
     CORE_PLATFORM_SUBSCRIPTION_HISTORY_TABLE = os.getenv("CORE_PLATFORM_SUBSCRIPTION_HISTORY_TABLE", "core_platform.cp_user_subscription_histories")
     CORE_PLATFORM_RESOURCE_DELETION_CHAT_HISTORY_TABLE = os.getenv("CORE_PLATFORM_RESOURCE_DELETION_CHAT_HISTORY_TABLE", "core_platform.cp_resource_deletion_chat_histories")
     CORE_PLATFORM_USER_GROUPS_TABLE = os.getenv("CORE_PLATFORM_USER_GROUPS_TABLE", "core_platform.cp_user_groups")
@@ -82,6 +74,7 @@ class Settings:
     CORE_PLATFORM_UNIT_OF_MEASURE_TABLE = os.getenv("CORE_PLATFORM_UNIT_OF_MEASURE_TABLE", "core_platform.cp_unit_of_measures")
     CORE_PLATFORM_CURRENCY = os.getenv("CORE_PLATFORM_CURRENCY", "core_platform.cp_currencies")
     CORE_PLATFORM_THEMES_TABLE = os.getenv("CORE_PLATFORM_THEMES_TABLE", "core_platform.cp_themes")
+    CORE_PLATFORM_NOTIFICATION_EMAIL_CREDENTIALS_TABLE = os.getenv("CORE_PLATFORM_NOTIFICATION_EMAIL_CREDENTIALS_TABLE", "core_platform.cp_notification_email_credentials")
 
     # Mail Configurations
     MAIL_SENDER_EMAIL=os.getenv("MAIL_SENDER_EMAIL")

trovesuite/utils/helper.py

@@ -96,11 +96,12 @@ class Helper:
 
             try:
                 if tenant_id:
-                    # For tenant-specific resource IDs, check shared schema with tenant_id filter
-                    tenant_resource_table = getattr(db_settings, 'CORE_PLATFORM_TENANT_RESOURCE_ID_TABLE', None) or getattr(db_settings, 'CORE_PLATFORM_RESOURCE_ID_TABLE', None)
-                    if tenant_resource_table:
+                    # For tenant-specific resource IDs, use CORE_PLATFORM_RESOURCE_ID_TABLE
+                    # This table has tenant_id column for filtering
+                    resource_table = getattr(db_settings, 'CORE_PLATFORM_RESOURCE_ID_TABLE', None)
+                    if resource_table:
                         resource_exists = DatabaseManager.execute_scalar(
-                            f"""SELECT COUNT(1) FROM {tenant_resource_table}
+                            f"""SELECT COUNT(1) FROM {resource_table}
                             WHERE tenant_id = %s AND id = %s""",
                             (tenant_id, candidate,),
                         )
@@ -108,7 +109,7 @@ class Helper:
                         # Fallback: assume no conflict if table not configured
                         resource_exists = 0
                 else:
-                    # For main schema resource IDs
+                    # For main/shared schema resource IDs (no tenant_id)
                     main_resource_table = getattr(db_settings, 'CORE_PLATFORM_RESOURCE_ID_TABLE', None)
                     if main_resource_table:
                         resource_exists = DatabaseManager.execute_scalar(
@@ -313,6 +314,75 @@ class Helper:
             # Log the error but don't fail the main operation
             logger.error(f"Failed to log activity: {str(e)}", exc_info=True)
 
+    @staticmethod
+    def get_email_credentials(tenant_id: Optional[str] = None) -> tuple[Optional[str], Optional[str]]:
+        """
+        Get email credentials for sending notifications.
+        If tenant_id is provided and tenant has custom email credentials, use those.
+        Otherwise, fall back to system default credentials.
+        
+        Args:
+            tenant_id: Optional tenant ID to check for tenant-specific credentials
+            
+        Returns:
+            Tuple of (email, password) or (None, None) if not configured
+        """
+        # If tenant_id is provided, check for tenant-specific credentials
+        if tenant_id:
+            try:
+                credentials_table = getattr(db_settings, 'CORE_PLATFORM_NOTIFICATION_EMAIL_CREDENTIALS_TABLE', 'core_platform.cp_notification_email_credentials')
+                tenant_credentials = DatabaseManager.execute_query(
+                    f"""SELECT notification_email, notification_password 
+                        FROM {credentials_table} 
+                        WHERE tenant_id = %s 
+                        AND delete_status = 'NOT_DELETED' 
+                        AND is_active = true""",
+                    (tenant_id,),
+                )
+                
+                if tenant_credentials and len(tenant_credentials) > 0:
+                    tenant_email = tenant_credentials[0].get('notification_email')
+                    tenant_password = tenant_credentials[0].get('notification_password')
+                    
+                    # If tenant has both email and password configured, use them
+                    if tenant_email and tenant_password:
+                        logger.info(
+                            f"Using tenant-specific email credentials for tenant {tenant_id}",
+                            extra={
+                                "extra_fields": {
+                                    "tenant_id": tenant_id,
+                                    "email": tenant_email
+                                }
+                            }
+                        )
+                        return (tenant_email, tenant_password)
+            except Exception as e:
+                logger.warning(
+                    f"Error fetching tenant email credentials for tenant {tenant_id}: {str(e)}",
+                    extra={
+                        "extra_fields": {
+                            "tenant_id": tenant_id,
+                            "error": str(e)
+                        }
+                    }
+                )
+        
+        # Fall back to system default credentials
+        mail_sender_email = getattr(db_settings, 'MAIL_SENDER_EMAIL', None)
+        mail_sender_pwd = getattr(db_settings, 'MAIL_SENDER_PWD', None)
+        
+        if tenant_id:
+            logger.info(
+                f"Using system default email credentials for tenant {tenant_id}",
+                extra={
+                    "extra_fields": {
+                        "tenant_id": tenant_id
+                    }
+                }
+            )
+        
+        return (mail_sender_email, mail_sender_pwd)
+
     @staticmethod
     def send_notification(
         email: str,
@@ -320,8 +390,19 @@ class Helper:
         text_template: str,
         html_template: str,
         variables: Optional[Dict[str, str]] = None,
+        tenant_id: Optional[str] = None,
     ):
-        """Send a dynamic notification email."""
+        """
+        Send a dynamic notification email.
+        
+        Args:
+            email: Recipient email address
+            subject: Email subject
+            text_template: Plain text email template
+            html_template: HTML email template
+            variables: Optional dictionary of variables to format templates
+            tenant_id: Optional tenant ID to use tenant-specific email credentials
+        """
         current_time = Helper.current_date_time()
         cdate = current_time["cdate"]
         ctime = current_time["ctime"]
@@ -344,12 +425,19 @@ class Helper:
         text_message = text_template.format(**safe_variables)
         html_message = html_template.format(**safe_variables)
 
-        # Build email data
-        mail_sender_email = getattr(db_settings, 'MAIL_SENDER_EMAIL', None)
-        mail_sender_pwd = getattr(db_settings, 'MAIL_SENDER_PWD', None)
+        # Get email credentials (tenant-specific or system default)
+        mail_sender_email, mail_sender_pwd = Helper.get_email_credentials(tenant_id)
 
         if not mail_sender_email or not mail_sender_pwd:
-            logger.error("MAIL_SENDER_EMAIL or MAIL_SENDER_PWD not configured in settings")
+            logger.error(
+                "Email credentials not configured. MAIL_SENDER_EMAIL or MAIL_SENDER_PWD not set in settings",
+                extra={
+                    "extra_fields": {
+                        "tenant_id": tenant_id,
+                        "receiver_email": email
+                    }
+                }
+            )
             return
 
         notification_data = NotificationEmailServiceWriteDto(
@@ -625,6 +713,7 @@ class Helper:
                         "message_row_style": message_row_style,
                         "app_url": app_url,
                     },
+                    tenant_id=tenant_id,
                 )
 
             logger.info(

{trovesuite-1.0.24.dist-info → trovesuite-1.0.31.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trovesuite
-Version: 1.0.24
+Version: 1.0.31
 Summary: TroveSuite services package providing authentication, authorization, notifications, Azure Storage, and other enterprise services for TroveSuite applications
 Home-page: https://dev.azure.com/brightgclt/trovesuite/_git/packages
 Author: Bright Debrah Owusu

{trovesuite-1.0.24.dist-info → trovesuite-1.0.31.dist-info}/RECORD

@@ -1,4 +1,4 @@
-trovesuite/__init__.py,sha256=vKnbXtMVw2mVbOuJLD1GhwcIx0oaNnyUL7Mrpk9Qa-I,646
+trovesuite/__init__.py,sha256=tcNxxwRpfYZ23yCEn4b5EHqGL5zRe_BqQHLcNAP23PQ,646
 trovesuite/auth/__init__.py,sha256=OjZllVvjul1glDazJ-d5TrNjgHFigFlQQi1G99DYshk,239
 trovesuite/auth/auth_base.py,sha256=rZHQVLeJRBQ8GClgF5UwG-er4_HXVX5-nt8o6_Z29uY,75
 trovesuite/auth/auth_controller.py,sha256=PAgaVlf5TYEfkSfK4vGGsvO84i8zEmeVVXyUF2YBppI,420
@@ -6,9 +6,9 @@ trovesuite/auth/auth_read_dto.py,sha256=e27JqKVPVUM83A_mYF452QCflsvGNo7aKje7q_ur
 trovesuite/auth/auth_service.py,sha256=TQOJFG0AzhPGwZBAXVxMkHxyG2wyct4Zcoq4z0cVBO4,22201
 trovesuite/auth/auth_write_dto.py,sha256=rdwI7w6-9QZGv1H0PAGrjkLBCzaMHjgPIXeLb9RmNec,234
 trovesuite/configs/__init__.py,sha256=h1mSZOaZ3kUy1ZMO_m9O9KklsxywM0RfMVZLh9h9WvQ,328
-trovesuite/configs/database.py,sha256=IPSu8fXjxyYeJ3bFknJG06Qm2L2ub6Ht19xhKv8g7nA,11731
+trovesuite/configs/database.py,sha256=83lckIpRLNLKgLNzXdzczlGjCRAM6DDFLyJTMxleyfw,15008
 trovesuite/configs/logging.py,sha256=mGjR2d4urVNry9l5_aXycMMtcY2RAFIpEL35hw33KZg,9308
-trovesuite/configs/settings.py,sha256=cogrBmLoKUTwzsFrMecMMXqPbyRZNCaFvotMqykh0gk,7300
+trovesuite/configs/settings.py,sha256=s-RvzFI7IR8-Q_A0ZRxlTr-iDoY6MvbxM0RkbhmJOL4,6915
 trovesuite/entities/__init__.py,sha256=Dbl_03Bueyh2vOP2hykd40MmNMrl5nNHSRGP-kqwwNo,160
 trovesuite/entities/health.py,sha256=KaW7yxTQdymIPlnkJJkDqEebBXkD0a7A66i5GgNZLoE,2700
 trovesuite/entities/sh_response.py,sha256=1_sw3PpVaDxWsNiBU0W9YLHZgTFxEj4JJBLBfSY63Ho,1579
@@ -25,10 +25,10 @@ trovesuite/storage/storage_read_dto.py,sha256=o7EVJdwrwVZAaeyGU9O01WMECGVaytkvLR
 trovesuite/storage/storage_service.py,sha256=V7LIePIV6b_iuhm-9x8r4zwpZHgeRPL1YIe5IBnxhco,19768
 trovesuite/storage/storage_write_dto.py,sha256=vl1iCZ93bpFmpvkCrn587QtMtOA_TPDseXSoTuj9RTQ,1355
 trovesuite/utils/__init__.py,sha256=mDZuY77BphvQFYLmcWxjP5Tcq9ZZ3WXJWBKB1v6wzHU,185
-trovesuite/utils/helper.py,sha256=xrr9W_JfhLckHGAgh4ECjsnMz_DIRXfUbwqVRlvLJfI,27070
+trovesuite/utils/helper.py,sha256=qpd-EWPaX3-QJA5xvxb4s9rEb9W2RKPCDXcdAKSUwSM,30858
 trovesuite/utils/templates.py,sha256=_92k4-EkqWs-h0LNJxPgorbspmp24kDngS7O3qWIFyQ,20388
-trovesuite-1.0.24.dist-info/licenses/LICENSE,sha256=EJT35ct-Q794JYPdAQy3XNczQGKkU1HzToLeK1YVw2s,1070
-trovesuite-1.0.24.dist-info/METADATA,sha256=lEIZkE_5Rv12-EU3BfsLShJZWlrpOXDEUp9QyJFnrYg,21737
-trovesuite-1.0.24.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-trovesuite-1.0.24.dist-info/top_level.txt,sha256=GzKhG_-MTaxeHrIgkGkBH_nof2vroGFBrjeHKWUIwNc,11
-trovesuite-1.0.24.dist-info/RECORD,,
+trovesuite-1.0.31.dist-info/licenses/LICENSE,sha256=EJT35ct-Q794JYPdAQy3XNczQGKkU1HzToLeK1YVw2s,1070
+trovesuite-1.0.31.dist-info/METADATA,sha256=gPt59uOFfKxbY9v0WuWclaw4ex4l-UVO-GyNte45apo,21737
+trovesuite-1.0.31.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+trovesuite-1.0.31.dist-info/top_level.txt,sha256=GzKhG_-MTaxeHrIgkGkBH_nof2vroGFBrjeHKWUIwNc,11
+trovesuite-1.0.31.dist-info/RECORD,,