maleo-database 0.0.15__tar.gz → 0.0.18__tar.gz

{maleo_database-0.0.15 → maleo_database-0.0.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo-database
-Version: 0.0.15
+Version: 0.0.18
 Summary: Database package for MaleoSuite
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: Proprietary
@@ -44,12 +44,12 @@ Requires-Dist: identify>=2.6.13
 Requires-Dist: idna>=3.10
 Requires-Dist: importlib_metadata>=8.7.0
 Requires-Dist: maleo-constants>=0.0.6
-Requires-Dist: maleo-dtos>=0.0.17
+Requires-Dist: maleo-dtos>=0.0.18
 Requires-Dist: maleo-enums>=0.0.6
-Requires-Dist: maleo-exceptions>=0.0.21
-Requires-Dist: maleo-logging>=0.0.7
+Requires-Dist: maleo-exceptions>=0.0.24
+Requires-Dist: maleo-logging>=0.0.8
 Requires-Dist: maleo-mixins>=0.0.13
-Requires-Dist: maleo-schemas>=0.0.20
+Requires-Dist: maleo-schemas>=0.0.21
 Requires-Dist: maleo-types-base>=0.0.2
 Requires-Dist: maleo-types-controllers>=0.0.1
 Requires-Dist: maleo-types-enums>=0.0.4

{maleo_database-0.0.15 → maleo_database-0.0.18}/maleo_database.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo-database
-Version: 0.0.15
+Version: 0.0.18
 Summary: Database package for MaleoSuite
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: Proprietary
@@ -44,12 +44,12 @@ Requires-Dist: identify>=2.6.13
 Requires-Dist: idna>=3.10
 Requires-Dist: importlib_metadata>=8.7.0
 Requires-Dist: maleo-constants>=0.0.6
-Requires-Dist: maleo-dtos>=0.0.17
+Requires-Dist: maleo-dtos>=0.0.18
 Requires-Dist: maleo-enums>=0.0.6
-Requires-Dist: maleo-exceptions>=0.0.21
-Requires-Dist: maleo-logging>=0.0.7
+Requires-Dist: maleo-exceptions>=0.0.24
+Requires-Dist: maleo-logging>=0.0.8
 Requires-Dist: maleo-mixins>=0.0.13
-Requires-Dist: maleo-schemas>=0.0.20
+Requires-Dist: maleo-schemas>=0.0.21
 Requires-Dist: maleo-types-base>=0.0.2
 Requires-Dist: maleo-types-controllers>=0.0.1
 Requires-Dist: maleo-types-enums>=0.0.4

{maleo_database-0.0.15 → maleo_database-0.0.18}/maleo_database.egg-info/SOURCES.txt

@@ -9,6 +9,7 @@ maleo_database.egg-info/top_level.txt
 src/__init__.py
 src/dtos.py
 src/enums.py
+src/handlers.py
 src/config/__init__.py
 src/config/additional.py
 src/config/connection.py

{maleo_database-0.0.15 → maleo_database-0.0.18}/maleo_database.egg-info/requires.txt

@@ -35,12 +35,12 @@ identify>=2.6.13
 idna>=3.10
 importlib_metadata>=8.7.0
 maleo-constants>=0.0.6
-maleo-dtos>=0.0.17
+maleo-dtos>=0.0.18
 maleo-enums>=0.0.6
-maleo-exceptions>=0.0.21
-maleo-logging>=0.0.7
+maleo-exceptions>=0.0.24
+maleo-logging>=0.0.8
 maleo-mixins>=0.0.13
-maleo-schemas>=0.0.20
+maleo-schemas>=0.0.21
 maleo-types-base>=0.0.2
 maleo-types-controllers>=0.0.1
 maleo-types-enums>=0.0.4

{maleo_database-0.0.15 → maleo_database-0.0.18}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maleo-database"
-version = "0.0.15"
+version = "0.0.18"
 description = "Database package for MaleoSuite"
 authors = [
     { name = "Agra Bima Yuda", email = "agra@nexmedis.com" }
@@ -50,12 +50,12 @@ dependencies = [
     "idna>=3.10",
     "importlib_metadata>=8.7.0",
     "maleo-constants>=0.0.6",
-    "maleo-dtos>=0.0.17",
+    "maleo-dtos>=0.0.18",
     "maleo-enums>=0.0.6",
-    "maleo-exceptions>=0.0.21",
-    "maleo-logging>=0.0.7",
+    "maleo-exceptions>=0.0.24",
+    "maleo-logging>=0.0.8",
     "maleo-mixins>=0.0.13",
-    "maleo-schemas>=0.0.20",
+    "maleo-schemas>=0.0.21",
     "maleo-types-base>=0.0.2",
     "maleo-types-controllers>=0.0.1",
     "maleo-types-enums>=0.0.4",

{maleo_database-0.0.15 → maleo_database-0.0.18}/src/config/__init__.py

@@ -6,7 +6,7 @@ from redis.asyncio import Redis as AsyncRedis
 from redis import Redis as SyncRedis
 from sqlalchemy.engine import create_engine as create_sync_engine, Engine
 from sqlalchemy.ext.asyncio import create_async_engine, AsyncEngine
-from typing import Generic, Literal, TypeVar, Union, overload
+from typing import Generic, Literal, Optional, TypeVar, Union, overload
 from maleo.types.base.dict import StringToAnyDict
 from ..enums import Connection
 from .additional import AdditionalConfigT, RedisAdditionalConfig
@@ -16,7 +16,7 @@ from .connection import (
     MySQLConnectionConfig,
     SQLiteConnectionConfig,
     SQLServerConnectionConfig,
-    MongoDBConnectionConfig,
+    MongoConnectionConfig,
     RedisConnectionConfig,
     ElasticsearchConnectionConfig,
 )
@@ -27,7 +27,7 @@ from .pooling import (
     MySQLPoolingConfig,
     SQLitePoolingConfig,
     SQLServerPoolingConfig,
-    MongoDBPoolingConfig,
+    MongoPoolingConfig,
     RedisPoolingConfig,
     ElasticsearchPoolingConfig,
 )
@@ -204,10 +204,10 @@ class ElasticsearchConfig(
             return Elasticsearch(hosts, **self.client_kwargs)
 
 
-class MongoDBConfig(
+class MongoConfig(
     BaseConfig[
-        MongoDBConnectionConfig,
-        MongoDBPoolingConfig,
+        MongoConnectionConfig,
+        MongoPoolingConfig,
         None,
     ]
 ):
@@ -261,30 +261,116 @@ class RedisConfig(
 NoSQLConfigT = TypeVar(
     "NoSQLConfigT",
     ElasticsearchConfig,
-    MongoDBConfig,
+    MongoConfig,
     RedisConfig,
 )
 
 
-DatabaseConfigT = TypeVar(
-    "DatabaseConfigT",
-    PostgreSQLConfig,
+ConfigT = TypeVar(
+    "ConfigT",
+    ElasticsearchConfig,
+    MongoConfig,
+    RedisConfig,
     MySQLConfig,
+    PostgreSQLConfig,
     SQLiteConfig,
     SQLServerConfig,
-    MongoDBConfig,
-    RedisConfig,
-    ElasticsearchConfig,
 )
 
 
-# * This class is left empty to be overridden in the future when defining configuration
-class Config(BaseModel):
-    pass
+class ElasticsearchConfigs(BaseModel):
+    primary: ElasticsearchConfig = Field(
+        ..., description="Primary Elasticsearch config"
+    )
+
+
+ElasticsearchConfigsT = TypeVar(
+    "ElasticsearchConfigsT", bound=Optional[ElasticsearchConfigs]
+)
+
+
+class MongoConfigs(BaseModel):
+    primary: MongoConfig = Field(..., description="Primary Mongo config")
+
+
+MongoConfigsT = TypeVar("MongoConfigsT", bound=Optional[MongoConfigs])
+
+
+class RedisConfigs(BaseModel):
+    primary: RedisConfig = Field(..., description="Primary Redis config")
+
+
+RedisConfigsT = TypeVar("RedisConfigsT", bound=Optional[RedisConfigs])
+
+
+class NoSQLConfigs(
+    BaseModel, Generic[ElasticsearchConfigsT, MongoConfigsT, RedisConfigsT]
+):
+    elasticsearch: ElasticsearchConfigsT = Field(
+        ..., description="Elasticsearch configs"
+    )
+    mongo: MongoConfigsT = Field(..., description="Mongo configs")
+    redis: RedisConfigsT = Field(..., description="Redis configs")
+
+
+NoSQLConfigsT = TypeVar("NoSQLConfigsT", bound=Optional[NoSQLConfigs])
 
 
-ConfigT = TypeVar("ConfigT", bound=Config)
+class MySQLConfigs(BaseModel):
+    primary: MySQLConfig = Field(..., description="Primary MySQL config")
+
+
+MySQLConfigsT = TypeVar("MySQLConfigsT", bound=Optional[MySQLConfigs])
+
+
+class PostgreSQLConfigs(BaseModel):
+    primary: PostgreSQLConfig = Field(..., description="Primary PostgreSQL config")
+
+
+PostgreSQLConfigsT = TypeVar("PostgreSQLConfigsT", bound=Optional[PostgreSQLConfigs])
+
+
+class SQLiteConfigs(BaseModel):
+    primary: SQLiteConfig = Field(..., description="Primary SQLite config")
+
+
+SQLiteConfigsT = TypeVar("SQLiteConfigsT", bound=Optional[SQLiteConfigs])
+
+
+class SQLServerConfigs(BaseModel):
+    primary: SQLServerConfig = Field(..., description="Primary SQLServer config")
+
+
+SQLServerConfigsT = TypeVar("SQLServerConfigsT", bound=Optional[SQLServerConfigs])
+
+
+class SQLConfigs(
+    BaseModel,
+    Generic[
+        MySQLConfigsT,
+        PostgreSQLConfigsT,
+        SQLiteConfigsT,
+        SQLServerConfigsT,
+    ],
+):
+    mysql: MySQLConfigsT = Field(..., description="MySQL configs")
+    postgresql: PostgreSQLConfigsT = Field(..., description="PostgreSQL configs")
+    sqlite: SQLiteConfigsT = Field(..., description="SQLite configs")
+    sqlserver: SQLServerConfigsT = Field(..., description="SQLServer configs")
+
+
+SQLConfigsT = TypeVar("SQLConfigsT", bound=Optional[SQLConfigs])
+
+
+class Configs(
+    BaseModel,
+    Generic[
+        NoSQLConfigsT,
+        SQLConfigsT,
+    ],
+):
+    nosql: NoSQLConfigsT = Field(..., description="NoSQL configs")
+    sql: SQLConfigsT = Field(..., description="SQL configs")
 
 
-class ConfigMixin(BaseModel, Generic[ConfigT]):
-    database: ConfigT = Field(..., description="Databases config")
+ConfigsT = TypeVar("ConfigsT", bound=Optional[Configs])

{maleo_database-0.0.15 → maleo_database-0.0.18}/src/config/connection.py

@@ -14,7 +14,7 @@ from ..enums import (
     Driver,
     PostgreSQLSSLMode,
     MySQLCharset,
-    MongoDBReadPreference,
+    MongoReadPreference,
     ElasticsearchScheme,
 )
 
@@ -41,7 +41,7 @@ class BaseConnectionConfig(
 
     # Optional fields for different database types
     auth_source: OptionalString = Field(
-        None, description="Authentication database (MongoDB)"
+        None, description="Authentication database (Mongo)"
     )
     ssl: OptionalBoolean = Field(None, description="Enable SSL connection")
     options: OptionalStringToAnyDict = Field(
@@ -70,7 +70,7 @@ class BaseConnectionConfig(
                 raise ValueError("Redis requires host")
         elif self.driver is Driver.MONGODB:
             if not self.host:
-                raise ValueError("MongoDB requires host")
+                raise ValueError("Mongo requires host")
 
         return self
 
@@ -141,7 +141,7 @@ class BaseConnectionConfig(
         raise NotImplementedError()
 
     def _make_mongodb_url(self) -> str:
-        """MongoDB URL format - MongoDB driver handles async/sync internally."""
+        """Mongo URL format - Mongo driver handles async/sync internally."""
         raise NotImplementedError()
 
     def _make_redis_url(self) -> str:
@@ -409,21 +409,21 @@ class SQLServerConnectionConfig(
         return self.model_dump(include={"echo"}, exclude_none=True)
 
 
-class MongoDBConnectionConfig(
+class MongoConnectionConfig(
     BaseConnectionConfig[
         Literal[Driver.MONGODB], OptionalString, OptionalString, str, int, str
     ]
 ):
     driver: Literal[Driver.MONGODB] = Driver.MONGODB
-    port: int = Field(27017, description="MongoDB port")
-    username: OptionalString = Field(None, description="MongoDB username")
-    password: OptionalString = Field(None, description="MongoDB password")
+    port: int = Field(27017, description="Mongo port")
+    username: OptionalString = Field(None, description="Mongo username")
+    password: OptionalString = Field(None, description="Mongo password")
 
-    # MongoDB-specific options
+    # Mongo-specific options
     auth_source: OptionalString = Field("admin", description="Authentication database")
     replica_set: OptionalString = Field(None, description="Replica set name")
-    read_preference: Optional[MongoDBReadPreference] = Field(
-        MongoDBReadPreference.PRIMARY, description="Read preference"
+    read_preference: Optional[MongoReadPreference] = Field(
+        MongoReadPreference.PRIMARY, description="Read preference"
     )
 
     @model_validator(mode="after")
@@ -436,8 +436,8 @@ class MongoDBConnectionConfig(
         return self
 
     def _make_mongodb_url(self) -> str:
-        """MongoDB URL format - MongoDB driver handles async/sync internally."""
-        # MongoDB uses the same URL format for both async and sync
+        """Mongo URL format - Mongo driver handles async/sync internally."""
+        # Mongo uses the same URL format for both async and sync
         # The async/sync behavior is determined by the client library used
 
         auth_part = ""
@@ -448,7 +448,7 @@ class MongoDBConnectionConfig(
 
         base_url = f"mongodb://{auth_part}{self.host}:{self.port}/{self.database}"
 
-        # Add MongoDB-specific options
+        # Add Mongo-specific options
         mongo_options = {
             "authSource": self.auth_source,
             "replicaSet": self.replica_set,
@@ -547,7 +547,7 @@ def create_connection_config(driver: Driver, **kwargs) -> BaseConnectionConfig:
         Driver.POSTGRESQL: PostgreSQLConnectionConfig,
         Driver.MYSQL: MySQLConnectionConfig,
         Driver.SQLITE: SQLiteConnectionConfig,
-        Driver.MONGODB: MongoDBConnectionConfig,
+        Driver.MONGODB: MongoConnectionConfig,
         Driver.REDIS: RedisConnectionConfig,
         Driver.MSSQL: SQLServerConnectionConfig,
         Driver.ELASTICSEARCH: ElasticsearchConnectionConfig,

{maleo_database-0.0.15 → maleo_database-0.0.18}/src/config/pooling.py

@@ -258,8 +258,8 @@ class ElasticsearchPoolingConfig(BasePoolingConfig):
         return self.model_dump(exclude=self.client_kwargs_exclusions, exclude_none=True)
 
 
-class MongoDBPoolingConfig(BasePoolingConfig):
-    """MongoDB-specific pooling configuration."""
+class MongoPoolingConfig(BasePoolingConfig):
+    """Mongo-specific pooling configuration."""
 
     model_config = ConfigDict(alias_generator=to_camel)
 

{maleo_database-0.0.15 → maleo_database-0.0.18}/src/enums.py

@@ -65,7 +65,7 @@ class MySQLCharset(StrEnum):
     ASCII = "ascii"
 
 
-class MongoDBReadPreference(StrEnum):
+class MongoReadPreference(StrEnum):
     PRIMARY = "primary"
     PRIMARY_PREFERRED = "primaryPreferred"
     SECONDARY = "secondary"

maleo_database-0.0.18/src/handlers.py

@@ -0,0 +1,196 @@
+from pydantic import BaseModel, ConfigDict, Field
+from sqlalchemy import MetaData
+from typing import Generic, Optional, TypeVar
+from maleo.dtos.contexts.service import ServiceContext
+from maleo.logging.logger import Database
+from .config import (
+    ElasticsearchConfig,
+    MongoConfig,
+    RedisConfig,
+    MySQLConfig,
+    PostgreSQLConfig,
+    SQLiteConfig,
+    SQLServerConfig,
+    ConfigT,
+)
+from .managers import (
+    ElasticsearchManager,
+    MongoManager,
+    RedisManager,
+    MySQLManager,
+    PostgreSQLManager,
+    SQLiteManager,
+    SQLServerManager,
+    ManagerT,
+)
+
+
+class Handler(
+    BaseModel,
+    Generic[
+        ConfigT,
+        ManagerT,
+    ],
+):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+    config: ConfigT = Field(..., description="Config")
+    manager: ManagerT = Field(..., description="Manager")
+
+
+HandlerT = TypeVar("HandlerT", bound=Handler)
+
+
+class ElasticsearchHandler(Handler[ElasticsearchConfig, ElasticsearchManager]):
+    @classmethod
+    def new(
+        cls,
+        config: ElasticsearchConfig,
+        logger: Database,
+        service_context: Optional[ServiceContext] = None,
+    ) -> "ElasticsearchHandler":
+        manager = ElasticsearchManager(
+            config=config, logger=logger, service_context=service_context
+        )
+        return cls(config=config, manager=manager)
+
+
+class MongoHandler(Handler[MongoConfig, MongoManager]):
+    pass
+
+
+class RedisHandler(Handler[RedisConfig, RedisManager]):
+    pass
+
+
+class MySQLHandler(Handler[MySQLConfig, MySQLManager]):
+    pass
+
+
+class PostgreSQLHandler(Handler[PostgreSQLConfig, PostgreSQLManager]):
+    @classmethod
+    def new(
+        cls,
+        config: PostgreSQLConfig,
+        logger: Database,
+        metadata: MetaData,
+        service_context: Optional[ServiceContext] = None,
+    ) -> "PostgreSQLHandler":
+        manager = PostgreSQLManager(
+            config=config,
+            logger=logger,
+            metadata=metadata,
+            service_context=service_context,
+        )
+        return cls(config=config, manager=manager)
+
+
+class SQLiteHandler(Handler[SQLiteConfig, SQLiteManager]):
+    pass
+
+
+class SQLServerHandler(Handler[SQLServerConfig, SQLServerManager]):
+    pass
+
+
+class BaseHandlers(BaseModel, Generic[HandlerT]):
+    primary: HandlerT = Field(..., description="Primary handler")
+
+
+BaseHandlersT = TypeVar("BaseHandlersT", bound=Optional[BaseHandlers])
+
+
+class ElasticsearchHandlers(BaseHandlers[ElasticsearchHandler]):
+    pass
+
+
+ElasticsearchHandlersT = TypeVar(
+    "ElasticsearchHandlersT", bound=Optional[ElasticsearchHandlers]
+)
+
+
+class MongoHandlers(BaseHandlers[MongoHandler]):
+    pass
+
+
+MongoHandlersT = TypeVar("MongoHandlersT", bound=Optional[MongoHandlers])
+
+
+class RedisHandlers(BaseHandlers[RedisHandler]):
+    pass
+
+
+RedisHandlersT = TypeVar("RedisHandlersT", bound=Optional[RedisHandlers])
+
+
+class NoSQLHandlers(
+    BaseModel, Generic[ElasticsearchHandlersT, MongoHandlersT, RedisHandlersT]
+):
+    elasticsearch: ElasticsearchHandlersT = Field(
+        ..., description="Elasticsearch handlers"
+    )
+    mongo: MongoHandlersT = Field(..., description="Mongo handlers")
+    redis: RedisHandlersT = Field(..., description="Redis handlers")
+
+
+NoSQLHandlersT = TypeVar("NoSQLHandlersT", bound=Optional[NoSQLHandlers])
+
+
+class MySQLHandlers(BaseHandlers[MySQLHandler]):
+    pass
+
+
+MySQLHandlersT = TypeVar("MySQLHandlersT", bound=Optional[MySQLHandlers])
+
+
+class PostgreSQLHandlers(BaseHandlers[PostgreSQLHandler]):
+    pass
+
+
+PostgreSQLHandlersT = TypeVar("PostgreSQLHandlersT", bound=Optional[PostgreSQLHandlers])
+
+
+class SQLiteHandlers(BaseHandlers[SQLiteHandler]):
+    pass
+
+
+SQLiteHandlersT = TypeVar("SQLiteHandlersT", bound=Optional[SQLiteHandlers])
+
+
+class SQLServerHandlers(BaseHandlers[SQLServerHandler]):
+    pass
+
+
+SQLServerHandlersT = TypeVar("SQLServerHandlersT", bound=Optional[SQLServerHandlers])
+
+
+class SQLHandlers(
+    BaseModel,
+    Generic[
+        MySQLHandlersT,
+        PostgreSQLHandlersT,
+        SQLiteHandlersT,
+        SQLServerHandlersT,
+    ],
+):
+    mysql: MySQLHandlersT = Field(..., description="MySQL handlers")
+    postgresql: PostgreSQLHandlersT = Field(..., description="PostgreSQL handlers")
+    sqlite: SQLiteHandlersT = Field(..., description="SQLite handlers")
+    sqlserver: SQLServerHandlersT = Field(..., description="SQLServer handlers")
+
+
+SQLHandlersT = TypeVar("SQLHandlersT", bound=Optional[SQLHandlers])
+
+
+class Handlers(
+    BaseModel,
+    Generic[
+        NoSQLHandlersT,
+        SQLHandlersT,
+    ],
+):
+    nosql: NoSQLHandlersT = Field(..., description="NoSQL handlers")
+    sql: NoSQLHandlersT = Field(..., description="SQL handlers")
+
+
+HandlersT = TypeVar("HandlersT", bound=Optional[Handlers])

{maleo_database-0.0.15 → maleo_database-0.0.18}/src/managers/__init__.py

@@ -37,7 +37,7 @@ from ..config import (
     SQLServerConfig,
     SQLConfigT,
     ElasticsearchConfig,
-    MongoDBConfig,
+    MongoConfig,
     RedisConfig,
     NoSQLConfigT,
     ConfigT,
@@ -52,7 +52,7 @@ from .engine import EngineManager
 from .session import SessionManager
 
 
-class DatabaseManager(ABC, Generic[ConfigT]):
+class Manager(ABC, Generic[ConfigT]):
     def __init__(
         self,
         config: ConfigT,
@@ -96,12 +96,12 @@ class DatabaseManager(ABC, Generic[ConfigT]):
         pass
 
 
-class SQLDatabaseManager(DatabaseManager[SQLConfigT], Generic[SQLConfigT]):
+class SQLManager(Manager[SQLConfigT], Generic[SQLConfigT]):
     def __init__(
         self,
         config: SQLConfigT,
-        metadata: MetaData,
         logger: Database,
+        metadata: MetaData,
         service_context: Optional[ServiceContext] = None,
     ) -> None:
         super().__init__(config, logger, service_context)
@@ -124,7 +124,7 @@ class SQLDatabaseManager(DatabaseManager[SQLConfigT], Generic[SQLConfigT]):
     def session(self) -> SessionManager:
         return self._session_manager
 
-    async def async_check_connnection(
+    async def async_check_connection(
         self,
         operation_id: OptionalUUID = None,
         request_context: Optional[RequestContext] = None,
@@ -251,33 +251,33 @@ class SQLDatabaseManager(DatabaseManager[SQLConfigT], Generic[SQLConfigT]):
         await self._engine_manager.dispose()
 
 
-class MySQLDatabaseManager(SQLDatabaseManager[MySQLConfig]):
+class MySQLManager(SQLManager[MySQLConfig]):
     pass
 
 
-class PostgreSQLDatabaseManager(SQLDatabaseManager[PostgreSQLConfig]):
+class PostgreSQLManager(SQLManager[PostgreSQLConfig]):
     pass
 
 
-class SQLiteDatabaseManager(SQLDatabaseManager[SQLiteConfig]):
+class SQLiteManager(SQLManager[SQLiteConfig]):
     pass
 
 
-class SQLServerDatabaseManager(SQLDatabaseManager[SQLServerConfig]):
+class SQLServerManager(SQLManager[SQLServerConfig]):
     pass
 
 
-SQLDatabaseManagerT = TypeVar(
-    "SQLDatabaseManagerT",
-    MySQLDatabaseManager,
-    PostgreSQLDatabaseManager,
-    SQLiteDatabaseManager,
-    SQLServerDatabaseManager,
+SQLManagerT = TypeVar(
+    "SQLManagerT",
+    MySQLManager,
+    PostgreSQLManager,
+    SQLiteManager,
+    SQLServerManager,
 )
 
 
-class NoSQLDatabaseManager(
-    DatabaseManager[NoSQLConfigT],
+class NoSQLManager(
+    Manager[NoSQLConfigT],
     Generic[
         NoSQLConfigT,
         AsyncClientT,
@@ -287,12 +287,10 @@ class NoSQLDatabaseManager(
     def __init__(
         self,
         config: NoSQLConfigT,
-        metadata: MetaData,
         logger: Database,
         service_context: Optional[ServiceContext] = None,
     ) -> None:
         super().__init__(config, logger, service_context)
-        self._metadata = metadata
         self._operation_context.target.details = self._config.model_dump()
         self._client_manager = ClientManager[
             NoSQLConfigT,
@@ -308,7 +306,7 @@ class NoSQLDatabaseManager(
     ]:
         return self._client_manager
 
-    async def async_check_connnection(
+    async def async_check_connection(
         self,
         operation_id: OptionalUUID = None,
         request_context: Optional[RequestContext] = None,
@@ -360,42 +358,35 @@ class NoSQLDatabaseManager(
         await self._client_manager.dispose()
 
 
-class ElasticsearchDatabaseManager(
-    NoSQLDatabaseManager[ElasticsearchConfig, AsyncElasticsearch, Elasticsearch]
+class ElasticsearchManager(
+    NoSQLManager[ElasticsearchConfig, AsyncElasticsearch, Elasticsearch]
 ):
     pass
 
 
-class MongoDBDatabaseManager(
-    NoSQLDatabaseManager[MongoDBConfig, AsyncIOMotorClient, MongoClient]
-):
+class MongoManager(NoSQLManager[MongoConfig, AsyncIOMotorClient, MongoClient]):
     pass
 
 
-class RedisDatabaseManager(NoSQLDatabaseManager[RedisConfig, AsyncRedis, SyncRedis]):
+class RedisManager(NoSQLManager[RedisConfig, AsyncRedis, SyncRedis]):
     pass
 
 
-NoSQLDatabaseManagerT = TypeVar(
-    "NoSQLDatabaseManagerT",
-    ElasticsearchDatabaseManager,
-    MongoDBDatabaseManager,
-    RedisDatabaseManager,
-)
-
-
-GenericDatabaseManagerT = TypeVar(
-    "GenericDatabaseManagerT", SQLDatabaseManager, NoSQLDatabaseManager
+NoSQLManagerT = TypeVar(
+    "NoSQLManagerT",
+    ElasticsearchManager,
+    MongoManager,
+    RedisManager,
 )
 
 
-SpecificDatabaseManagerT = TypeVar(
-    "SpecificDatabaseManagerT",
-    MySQLDatabaseManager,
-    PostgreSQLDatabaseManager,
-    SQLiteDatabaseManager,
-    SQLServerDatabaseManager,
-    ElasticsearchDatabaseManager,
-    MongoDBDatabaseManager,
-    RedisDatabaseManager,
+ManagerT = TypeVar(
+    "ManagerT",
+    ElasticsearchManager,
+    MongoManager,
+    RedisManager,
+    MySQLManager,
+    PostgreSQLManager,
+    SQLiteManager,
+    SQLServerManager,
 )

{maleo_database-0.0.15 → maleo_database-0.0.18}/src/managers/client.py

@@ -7,7 +7,7 @@ from typing import Generic, Literal, Optional, Tuple, TypeVar, Union, overload
 from maleo.types.base.string import ListOfStrings
 from ..config import (
     ElasticsearchConfig,
-    MongoDBConfig,
+    MongoConfig,
     RedisConfig,
     NoSQLConfigT,
 )
@@ -65,9 +65,7 @@ class ElasticsearchClientManager(
     pass
 
 
-class MongoDBClientManager(
-    ClientManager[MongoDBConfig, AsyncIOMotorClient, MongoClient]
-):
+class MongoClientManager(ClientManager[MongoConfig, AsyncIOMotorClient, MongoClient]):
     pass
 
 
@@ -98,6 +96,6 @@ class RedisClientManager(ClientManager[RedisConfig, AsyncRedis, SyncRedis]):
 ClientManagerT = TypeVar(
     "ClientManagerT",
     ElasticsearchClientManager,
-    MongoDBClientManager,
+    MongoClientManager,
     RedisClientManager,
 )