maleo-database 0.0.21__tar.gz → 0.0.22__tar.gz

{maleo_database-0.0.21 → maleo_database-0.0.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo-database
-Version: 0.0.21
+Version: 0.0.22
 Summary: Database package for MaleoSuite
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: Proprietary

{maleo_database-0.0.21 → maleo_database-0.0.22}/maleo_database.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: maleo-database
-Version: 0.0.21
+Version: 0.0.22
 Summary: Database package for MaleoSuite
 Author-email: Agra Bima Yuda <agra@nexmedis.com>
 License: Proprietary

{maleo_database-0.0.21 → maleo_database-0.0.22}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "maleo-database"
-version = "0.0.21"
+version = "0.0.22"
 description = "Database package for MaleoSuite"
 authors = [
     { name = "Agra Bima Yuda", email = "agra@nexmedis.com" }

{maleo_database-0.0.21 → maleo_database-0.0.22}/src/handlers.py

@@ -1,8 +1,6 @@
 from pydantic import BaseModel, ConfigDict, Field
-from sqlalchemy import MetaData
+from sqlalchemy.orm import DeclarativeBase
 from typing import Generic, Optional, TypeVar
-from maleo.dtos.contexts.service import ServiceContext
-from maleo.logging.logger import Database
 from .config import (
     ElasticsearchConfig,
     MongoConfig,
@@ -42,17 +40,7 @@ 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)
+    pass
 
 
 class MongoHandler(Handler[MongoConfig, MongoManager]):
@@ -63,33 +51,22 @@ class RedisHandler(Handler[RedisConfig, RedisManager]):
     pass
 
 
-class MySQLHandler(Handler[MySQLConfig, MySQLManager]):
+T = TypeVar("T", bound=DeclarativeBase)
+
+
+class MySQLHandler(Handler[MySQLConfig, MySQLManager[T]], Generic[T]):
+    pass
+
+
+class PostgreSQLHandler(Handler[PostgreSQLConfig, PostgreSQLManager[T]], Generic[T]):
     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]):
+class SQLiteHandler(Handler[SQLiteConfig, SQLiteManager[T]], Generic[T]):
     pass
 
 
-class SQLServerHandler(Handler[SQLServerConfig, SQLServerManager]):
+class SQLServerHandler(Handler[SQLServerConfig, SQLServerManager[T]], Generic[T]):
     pass
 
 

{maleo_database-0.0.21 → maleo_database-0.0.22}/src/managers/__init__.py

@@ -6,8 +6,9 @@ from motor.motor_asyncio import AsyncIOMotorClient
 from pymongo import MongoClient
 from redis.asyncio import Redis as AsyncRedis
 from redis import Redis as SyncRedis
-from sqlalchemy import MetaData, text
-from typing import Generic, Optional, TypeVar
+from sqlalchemy.orm import DeclarativeBase
+from sqlalchemy import text
+from typing import Generic, Optional, Type, TypeVar
 from uuid import uuid4
 from maleo.dtos.authentication import GenericAuthentication
 from maleo.dtos.contexts.operation import generate_operation_context
@@ -96,16 +97,18 @@ class Manager(ABC, Generic[ConfigT]):
         pass
 
 
-class SQLManager(Manager[SQLConfigT], Generic[SQLConfigT]):
+T = TypeVar("T", bound=DeclarativeBase)
+
+
+class SQLManager(Manager[SQLConfigT], Generic[SQLConfigT, T]):
     def __init__(
         self,
+        Base: Type[T],
         config: SQLConfigT,
         logger: Database,
-        metadata: MetaData,
         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._engine_manager = EngineManager[SQLConfigT](config)
         self._session_manager = SessionManager(
@@ -114,7 +117,8 @@ class SQLManager(Manager[SQLConfigT], Generic[SQLConfigT]):
             logger=self._logger,
             service_context=self._service_context,
         )
-        self._metadata.create_all(bind=self._engine_manager.get(Connection.SYNC))
+        self.Base = Base
+        self.Base.metadata.create_all(bind=self._engine_manager.get(Connection.SYNC))
 
     @property
     def engine(self) -> EngineManager[SQLConfigT]:
@@ -251,19 +255,19 @@ class SQLManager(Manager[SQLConfigT], Generic[SQLConfigT]):
         await self._engine_manager.dispose()
 
 
-class MySQLManager(SQLManager[MySQLConfig]):
+class MySQLManager(SQLManager[MySQLConfig, T], Generic[T]):
     pass
 
 
-class PostgreSQLManager(SQLManager[PostgreSQLConfig]):
+class PostgreSQLManager(SQLManager[PostgreSQLConfig, T], Generic[T]):
     pass
 
 
-class SQLiteManager(SQLManager[SQLiteConfig]):
+class SQLiteManager(SQLManager[SQLiteConfig, T], Generic[T]):
     pass
 
 
-class SQLServerManager(SQLManager[SQLServerConfig]):
+class SQLServerManager(SQLManager[SQLServerConfig, T], Generic[T]):
     pass
 
 

{maleo_database-0.0.21 → maleo_database-0.0.22}/src/orm/queries.py

@@ -3,7 +3,7 @@ from sqlalchemy.orm import DeclarativeBase, Session, aliased
 from sqlalchemy.orm.attributes import InstrumentedAttribute
 from sqlalchemy.sql import Select
 from sqlalchemy.types import DATE, String, TEXT, TIMESTAMP
-from typing import Sequence, Type, TypeVar
+from typing import Any, Sequence, Tuple, Type, TypeVar
 from maleo.enums.sort import Order
 from maleo.mixins.general import DateFilter, SortColumn
 from maleo.types.base.any import OptionalAny
@@ -14,15 +14,18 @@ from maleo.types.enums.status import OptionalListOfDataStatuses
 
 
 T = TypeVar("T", bound=DeclarativeBase)
+R = TypeVar(
+    "R", bound=Tuple[Any, ...]
+)  # result shape inferred from Select (tuple[...])
 
 
 def filter_column(
-    stmt: Select,
+    stmt: Select[R],
     table: Type[T],
     column: str,
     value: OptionalAny = None,
     include_null: bool = False,
-) -> Select:
+) -> Select[R]:
     column_attr = getattr(table, column, None)
     if column_attr is None or not isinstance(column_attr, InstrumentedAttribute):
         return stmt
@@ -40,12 +43,12 @@ def filter_column(
 
 
 def filter_ids(
-    stmt: Select,
+    stmt: Select[R],
     table: Type[T],
     column: str,
     ids: OptionalListOfIntegers = None,
     include_null: bool = False,
-) -> Select:
+) -> Select[R]:
     column_attr = getattr(table, column, None)
     if column_attr is None or not isinstance(column_attr, InstrumentedAttribute):
         return stmt
@@ -63,10 +66,10 @@ def filter_ids(
 
 
 def filter_timestamps(
-    stmt: Select,
+    stmt: Select[R],
     table: Type[T],
     date_filters: Sequence[DateFilter],
-) -> Select:
+) -> Select[R]:
     if date_filters:
         for date_filter in date_filters:
             try:
@@ -90,10 +93,10 @@ def filter_timestamps(
 
 
 def filter_statuses(
-    stmt: Select,
+    stmt: Select[R],
     table: Type[T],
     statuses: OptionalListOfDataStatuses,
-) -> Select:
+) -> Select[R]:
     if statuses is not None:
         status_filters = [table.status == status for status in statuses]  # type: ignore
         stmt = stmt.filter(or_(*status_filters))
@@ -101,11 +104,11 @@ def filter_statuses(
 
 
 def filter_is_root(
-    stmt: Select,
+    stmt: Select[R],
     table: Type[T],
     parent_column: str = "parent_id",
     is_root: OptionalBoolean = None,
-) -> Select:
+) -> Select[R]:
     parent_attr = getattr(table, parent_column, None)
     if parent_attr is None or not isinstance(parent_attr, InstrumentedAttribute):
         return stmt
@@ -118,12 +121,12 @@ def filter_is_root(
 
 def filter_is_parent(
     session: Session,
-    stmt: Select,
+    stmt: Select[R],
     table: Type[T],
     id_column: str = "id",
     parent_column: str = "parent_id",
     is_parent: OptionalBoolean = None,
-) -> Select:
+) -> Select[R]:
     id_attr = getattr(table, id_column, None)
     if id_attr is None or not isinstance(id_attr, InstrumentedAttribute):
         return stmt
@@ -139,11 +142,11 @@ def filter_is_parent(
 
 
 def filter_is_child(
-    stmt: Select,
+    stmt: Select[R],
     table: Type[T],
     parent_column: str = "parent_id",
     is_child: OptionalBoolean = None,
-) -> Select:
+) -> Select[R]:
     parent_attr = getattr(table, parent_column, None)
     if parent_attr is None or not isinstance(parent_attr, InstrumentedAttribute):
         return stmt
@@ -156,12 +159,12 @@ def filter_is_child(
 
 def filter_is_leaf(
     session: Session,
-    stmt: Select,
+    stmt: Select[R],
     table: Type[T],
     id_column: str = "id",
     parent_column: str = "parent_id",
     is_leaf: OptionalBoolean = None,
-) -> Select:
+) -> Select[R]:
     id_attr = getattr(table, id_column, None)
     if id_attr is None or not isinstance(id_attr, InstrumentedAttribute):
         return stmt
@@ -177,11 +180,11 @@ def filter_is_leaf(
 
 
 def search(
-    stmt: Select,
+    stmt: Select[R],
     table: Type[T],
     search: OptionalString = None,
     columns: OptionalListOfStrings = None,
-) -> Select:
+) -> Select[R]:
     if search is None:
         return stmt
 
@@ -211,10 +214,10 @@ def search(
 
 
 def sort(
-    stmt: Select,
+    stmt: Select[R],
     table: Type[T],
     sort_columns: Sequence[SortColumn],
-) -> Select:
+) -> Select[R]:
     for sort_column in sort_columns:
         try:
             sort_col = getattr(table, sort_column.name)
@@ -227,7 +230,7 @@ def sort(
     return stmt
 
 
-def paginate(stmt: Select, page: int, limit: int) -> Select:
+def paginate(stmt: Select[R], page: int, limit: int) -> Select[R]:
     offset: int = int((page - 1) * limit)
     stmt = stmt.limit(limit).offset(offset)
     return stmt