maleo-database 0.0.4__py3-none-any.whl → 0.0.5__py3-none-any.whl

maleo/database/config/pooling.py

@@ -1,6 +1,6 @@
 from pydantic import BaseModel, ConfigDict, Field, model_validator
-from typing import Self, TypeVar
-from maleo.types.base.dict import OptionalStringToStringDict
+from typing import Self, Set, TypeVar
+from maleo.types.base.dict import OptionalStringToStringDict, StringToAnyDict
 from maleo.types.base.integer import ListOfIntegers
 from maleo.types.base.string import OptionalString
 from maleo.utils.formatters.case import to_camel
@@ -14,75 +14,95 @@ class BasePoolingConfig(BaseModel):
 PoolingConfigT = TypeVar("PoolingConfigT", bound=BasePoolingConfig)
 
 
-class PostgreSQLPoolingConfig(BasePoolingConfig):
-    """PostgreSQL-specific pooling configuration."""
+class MySQLPoolingConfig(BasePoolingConfig):
+    """MySQL-specific pooling configuration."""
 
     pool_size: int = Field(
-        default=10, ge=1, le=1000, description="Number of connections in the pool"
+        default=8, ge=1, le=500, description="Number of connections in the pool"
     )
     max_overflow: int = Field(
-        default=20, ge=0, le=500, description="Maximum number of overflow connections"
+        default=15, ge=0, le=200, description="Maximum number of overflow connections"
     )
     pool_timeout: float = Field(
-        default=30.0,
+        default=20.0,
         ge=1.0,
         le=300.0,
         description="Timeout in seconds for getting connection",
     )
     pool_recycle: int = Field(
-        default=3600, ge=60, le=86400, description="Connection recycle time in seconds"
+        default=7200, ge=60, le=86400, description="Connection recycle time in seconds"
     )
     pool_pre_ping: bool = Field(
         default=True, description="Validate connections before use"
     )
-    # Keep strategy and prepared_statement_cache_size as they're pooling-related
     strategy: PoolingStrategy = Field(
-        default=PoolingStrategy.DYNAMIC, description="Pooling strategy"
-    )
-    prepared_statement_cache_size: int = Field(
-        default=100, ge=0, le=10000, description="Prepared statement cache size"
+        default=PoolingStrategy.FIXED, description="Pooling strategy"
     )
-    pool_reset_on_return: bool = Field(
-        default=True, description="Reset connection state on return to pool"
+    # Add autocommit to pooling since it affects connection behavior in the pool
+    autocommit: bool = Field(default=False, description="Enable autocommit mode")
+    # Move connect_timeout here since it's about pool connection establishment
+    connect_timeout: float = Field(
+        default=10.0, ge=1.0, le=60.0, description="Connection timeout in seconds"
     )
 
-    @model_validator(mode="after")
-    def validate_overflow(self) -> Self:
-        if self.max_overflow > self.pool_size * 5:
-            raise ValueError("max_overflow should not exceed 5x pool_size")
-        return self
+    @property
+    def engine_kwargs_exclusions(self) -> Set[str]:
+        return {"strategy"}
 
+    @property
+    def engine_kwargs(self) -> StringToAnyDict:
+        return self.model_dump(exclude=self.engine_kwargs_exclusions, exclude_none=True)
 
-class MySQLPoolingConfig(BasePoolingConfig):
-    """MySQL-specific pooling configuration."""
+
+class PostgreSQLPoolingConfig(BasePoolingConfig):
+    """PostgreSQL-specific pooling configuration."""
 
     pool_size: int = Field(
-        default=8, ge=1, le=500, description="Number of connections in the pool"
+        default=10, ge=1, le=1000, description="Number of connections in the pool"
     )
     max_overflow: int = Field(
-        default=15, ge=0, le=200, description="Maximum number of overflow connections"
+        default=20, ge=0, le=500, description="Maximum number of overflow connections"
     )
     pool_timeout: float = Field(
-        default=20.0,
+        default=30.0,
         ge=1.0,
         le=300.0,
         description="Timeout in seconds for getting connection",
     )
     pool_recycle: int = Field(
-        default=7200, ge=60, le=86400, description="Connection recycle time in seconds"
+        default=3600, ge=60, le=86400, description="Connection recycle time in seconds"
     )
     pool_pre_ping: bool = Field(
         default=True, description="Validate connections before use"
     )
+    # Keep strategy and prepared_statement_cache_size as they're pooling-related
     strategy: PoolingStrategy = Field(
-        default=PoolingStrategy.FIXED, description="Pooling strategy"
+        default=PoolingStrategy.DYNAMIC, description="Pooling strategy"
     )
-    # Add autocommit to pooling since it affects connection behavior in the pool
-    autocommit: bool = Field(default=False, description="Enable autocommit mode")
-    # Move connect_timeout here since it's about pool connection establishment
-    connect_timeout: float = Field(
-        default=10.0, ge=1.0, le=60.0, description="Connection timeout in seconds"
+    prepared_statement_cache_size: int = Field(
+        default=100, ge=0, le=10000, description="Prepared statement cache size"
     )
+    pool_reset_on_return: bool = Field(
+        default=True, description="Reset connection state on return to pool"
+    )
+
+    @model_validator(mode="after")
+    def validate_overflow(self) -> Self:
+        if self.max_overflow > self.pool_size * 5:
+            raise ValueError("max_overflow should not exceed 5x pool_size")
+        return self
+
+    @property
+    def engine_kwargs_exclusions(self) -> Set[str]:
+        return {
+            "strategy",
+            "prepared_statement_cache_size",
+            "pool_reset_on_return",
+        }
+
+    @property
+    def engine_kwargs(self) -> StringToAnyDict:
+        return self.model_dump(exclude=self.engine_kwargs_exclusions, exclude_none=True)
 
 
 class SQLitePoolingConfig(BasePoolingConfig):
@@ -105,6 +125,18 @@ class SQLitePoolingConfig(BasePoolingConfig):
         default=30000, ge=1000, le=300000, description="Busy timeout in milliseconds"
     )
 
+    @property
+    def engine_kwargs_exclusions(self) -> Set[str]:
+        return {
+            "strategy",
+            "wal_mode",
+            "busy_timeout",
+        }
+
+    @property
+    def engine_kwargs(self) -> StringToAnyDict:
+        return self.model_dump(exclude=self.engine_kwargs_exclusions, exclude_none=True)
+
 
 class SQLServerPoolingConfig(BasePoolingConfig):
     """SQL Server-specific pooling configuration."""
@@ -152,6 +184,79 @@ class SQLServerPoolingConfig(BasePoolingConfig):
             raise ValueError("max_overflow should not exceed 3x pool_size")
         return self
 
+    @property
+    def engine_kwargs_exclusions(self) -> Set[str]:
+        return {
+            "connection_timeout",
+            "command_timeout",
+            "packet_size",
+            "trust_server_certificate",
+        }
+
+    @property
+    def engine_kwargs(self) -> StringToAnyDict:
+        return self.model_dump(exclude=self.engine_kwargs_exclusions, exclude_none=True)
+
+
+class ElasticsearchPoolingConfig(BasePoolingConfig):
+    """Elasticsearch-specific pooling configuration."""
+
+    # Connection pool settings
+    maxsize: int = Field(
+        default=25, ge=1, le=100, description="Maximum number of connections in pool"
+    )
+    connections_per_node: int = Field(
+        default=10, ge=1, le=50, description="Connections per Elasticsearch node"
+    )
+
+    # Timeout settings
+    timeout: float = Field(
+        default=10.0, ge=1.0, le=300.0, description="Request timeout in seconds"
+    )
+    max_retries: int = Field(
+        default=3, ge=0, le=10, description="Maximum number of retries"
+    )
+    retry_on_timeout: bool = Field(default=False, description="Retry on timeout")
+    retry_on_status: ListOfIntegers = Field(
+        default_factory=lambda: [502, 503, 504],
+        description="HTTP status codes to retry on",
+    )
+
+    # Connection behavior (move from connection config)
+    http_compress: bool = Field(default=True, description="Enable HTTP compression")
+    verify_certs: bool = Field(default=True, description="Verify SSL certificates")
+    ca_certs: OptionalString = Field(
+        default=None, description="Path to CA certificates"
+    )
+
+    # Advanced pool settings
+    block: bool = Field(default=False, description="Block when pool is full")
+    headers: OptionalStringToStringDict = Field(
+        default=None, description="Default headers for requests"
+    )
+    dead_timeout: float = Field(
+        default=60.0, ge=5.0, le=600.0, description="Dead node timeout in seconds"
+    )
+
+    @model_validator(mode="after")
+    def validate_overflow(self) -> Self:
+        if self.connections_per_node > self.maxsize:
+            raise ValueError("connections_per_node must not exceed maxsize")
+        return self
+
+    @property
+    def client_kwargs_exclusions(self) -> Set[str]:
+        return {
+            "connections_per_node",
+            "block",
+            "headers",
+            "dead_timeout",
+        }
+
+    @property
+    def client_kwargs(self) -> StringToAnyDict:
+        return self.model_dump(exclude=self.client_kwargs_exclusions, exclude_none=True)
+
 
 class MongoDBPoolingConfig(BasePoolingConfig):
     """MongoDB-specific pooling configuration."""
@@ -159,30 +264,52 @@ class MongoDBPoolingConfig(BasePoolingConfig):
     model_config = ConfigDict(alias_generator=to_camel)
 
     max_pool_size: int = Field(
-        default=100, ge=1, le=500, description="Maximum number of connections in pool"
+        100,
+        ge=1,
+        le=500,
+        description="Maximum number of connections in pool",
+        alias="maxPoolSiza",
     )
     min_pool_size: int = Field(
-        default=0, ge=0, le=100, description="Minimum number of connections in pool"
+        0,
+        ge=0,
+        le=100,
+        description="Minimum number of connections in pool",
+        alias="minPoolSize",
     )
     max_idle_time_ms: int = Field(
-        default=600000, ge=1000, le=3600000, description="Max idle time in milliseconds"
+        600000,
+        ge=1000,
+        le=3600000,
+        description="Max idle time in milliseconds",
+        alias="maxIdleTimeMS",
     )
     connect_timeout_ms: int = Field(
-        default=20000,
+        20000,
         ge=1000,
         le=300000,
         description="Connection timeout in milliseconds",
+        alias="connectTimeoutMS",
     )
     server_selection_timeout_ms: int = Field(
-        default=30000, ge=1000, le=300000, description="Server selection timeout"
+        30000,
+        ge=1000,
+        le=300000,
+        description="Server selection timeout",
+        alias="serverSelectionTimeoutMS",
     )
     max_connecting: int = Field(
-        default=2,
+        2,
         ge=1,
         le=10,
         description="Maximum number of concurrent connection attempts",
+        alias="maxConnecting",
     )
 
+    @property
+    def client_kwargs(self) -> StringToAnyDict:
+        return self.model_dump(by_alias=True, exclude_none=True)
+
 
 class RedisPoolingConfig(BasePoolingConfig):
     """Redis-specific pooling configuration."""
@@ -207,49 +334,10 @@ class RedisPoolingConfig(BasePoolingConfig):
         default=True, description="Decode responses to strings"
     )
 
+    @property
+    def client_kwargs_exclusions(self) -> Set[str]:
+        return {"health_check_interval"}
 
-class ElasticsearchPoolingConfig(BasePoolingConfig):
-    """Elasticsearch-specific pooling configuration."""
-
-    # Connection pool settings
-    maxsize: int = Field(
-        default=25, ge=1, le=100, description="Maximum number of connections in pool"
-    )
-    connections_per_node: int = Field(
-        default=10, ge=1, le=50, description="Connections per Elasticsearch node"
-    )
-
-    # Timeout settings
-    timeout: float = Field(
-        default=10.0, ge=1.0, le=300.0, description="Request timeout in seconds"
-    )
-    max_retries: int = Field(
-        default=3, ge=0, le=10, description="Maximum number of retries"
-    )
-    retry_on_timeout: bool = Field(default=False, description="Retry on timeout")
-    retry_on_status: ListOfIntegers = Field(
-        default_factory=lambda: [502, 503, 504],
-        description="HTTP status codes to retry on",
-    )
-
-    # Connection behavior (move from connection config)
-    http_compress: bool = Field(default=True, description="Enable HTTP compression")
-    verify_certs: bool = Field(default=True, description="Verify SSL certificates")
-    ca_certs: OptionalString = Field(
-        default=None, description="Path to CA certificates"
-    )
-
-    # Advanced pool settings
-    block: bool = Field(default=False, description="Block when pool is full")
-    headers: OptionalStringToStringDict = Field(
-        default=None, description="Default headers for requests"
-    )
-    dead_timeout: float = Field(
-        default=60.0, ge=5.0, le=600.0, description="Dead node timeout in seconds"
-    )
-
-    @model_validator(mode="after")
-    def validate_overflow(self) -> Self:
-        if self.connections_per_node > self.maxsize:
-            raise ValueError("connections_per_node must not exceed maxsize")
-        return self
+    @property
+    def client_kwargs(self) -> StringToAnyDict:
+        return self.model_dump(exclude=self.client_kwargs_exclusions, exclude_none=True)

maleo/database/dtos.py

@@ -0,0 +1,6 @@
+from pydantic import BaseModel, Field
+
+
+class ConnectionCheck(BaseModel):
+    is_connected: bool = Field(..., description="Whether database is connected")
+    duration: float = Field(..., ge=0.0, description="Duration")