database-wrapper 0.1.44__tar.gz → 0.1.72__tar.gz

{database_wrapper-0.1.44 → database_wrapper-0.1.72}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: database_wrapper
-Version: 0.1.44
+Version: 0.1.72
 Summary: A Different Approach to Database Wrappers in Python
 Author-email: Gints Murans <gm@gm.lv>
 License: GNU General Public License v3.0 (GPL-3.0)
@@ -33,13 +33,13 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 Provides-Extra: pgsql
-Requires-Dist: database_wrapper_pgsql==0.1.44; extra == "pgsql"
+Requires-Dist: database_wrapper_pgsql==0.1.72; extra == "pgsql"
 Provides-Extra: mysql
-Requires-Dist: database_wrapper_mysql==0.1.44; extra == "mysql"
+Requires-Dist: database_wrapper_mysql==0.1.72; extra == "mysql"
 Provides-Extra: mssql
-Requires-Dist: database_wrapper_mssql==0.1.44; extra == "mssql"
+Requires-Dist: database_wrapper_mssql==0.1.72; extra == "mssql"
 Provides-Extra: sqlite
-Requires-Dist: database_wrapper_sqlite==0.1.44; extra == "sqlite"
+Requires-Dist: database_wrapper_sqlite==0.1.72; extra == "sqlite"
 Provides-Extra: all
 Requires-Dist: database_wrapper[mssql,mysql,pgsql,sqlite]; extra == "all"
 Provides-Extra: dev
@@ -47,8 +47,10 @@ Requires-Dist: ast-comments>=1.1.2; extra == "dev"
 Requires-Dist: codespell>=2.2; extra == "dev"
 Requires-Dist: build>=1.2.1; extra == "dev"
 Requires-Dist: black>=24.1.0; extra == "dev"
+Requires-Dist: mypy>=1.9.0; extra == "dev"
 Requires-Dist: types-setuptools>=61.0.0; extra == "dev"
 Requires-Dist: types-pymssql>=2.1.0; extra == "dev"
+Requires-Dist: types-mysqlclient>=2.2.0; extra == "dev"
 Requires-Dist: psycopg[binary]>=3.2.0; extra == "dev"
 Requires-Dist: psycopg[pool]>=3.2.0; extra == "dev"
 Requires-Dist: mysqlclient>=2.2.2; extra == "dev"

{database_wrapper-0.1.44 → database_wrapper-0.1.72}/database_wrapper/__init__.py

@@ -6,12 +6,15 @@ database_wrapper package - Base for database wrappers
 
 import logging
 
+from .abc import ConnectionABC, CursorABC, CursorAsyncABC, ConnectionAsyncABC
 from . import utils
 from .db_backend import DatabaseBackend
-from .db_data_model import DBDataModel, DBDefaultsDataModel
+from .db_data_model import MetadataDict, DBDataModel, DBDefaultsDataModel
 from .common import OrderByItem, DataModelType, NoParam
 from .db_wrapper import DBWrapper
 from .db_wrapper_async import DBWrapperAsync
+from .serialization import SerializeType
+from .utils.dataclass_addons import ignore_unknown_kwargs
 
 # Set the logger to a quiet default, can be enabled if needed
 logger = logging.getLogger("database_wrapper")
@@ -30,8 +33,16 @@ __all__ = [
     "DBWrapper",
     "DBWrapperAsync",
     # Helpers
+    "MetadataDict",
     "DataModelType",
     "OrderByItem",
     "NoParam",
     "utils",
+    "SerializeType",
+    "ignore_unknown_kwargs",
+    # Abstract classes
+    "ConnectionABC",
+    "CursorABC",
+    "CursorAsyncABC",
+    "ConnectionAsyncABC",
 ]

database_wrapper-0.1.72/database_wrapper/abc.py

@@ -0,0 +1,68 @@
+from typing import Dict, Any, Literal
+from typing import Any, Protocol, Sequence
+
+from psycopg.sql import Composable
+
+Row = Dict[str, Any]
+
+
+class CursorABC(Protocol):
+    def execute(
+        self,
+        operation: str | Composable,
+        parameters: Sequence[Any] | None = None,
+    ) -> None: ...
+    def executemany(
+        self,
+        operation: str | Composable,
+        seq_of_parameters: Sequence[Sequence[Any]],
+    ) -> None: ...
+    def fetchone(self) -> Row | None: ...
+    def fetchmany(self, size: int | None = None) -> list[Row]: ...
+    def fetchall(self) -> list[Row]: ...
+    def close(self) -> None: ...
+    def setinputsizes(self, sizes: Sequence[Any]) -> None: ...
+    def setoutputsize(self, size: Any, column: Any = None) -> None: ...
+
+    @property
+    def rowcount(self) -> int | Literal[-1]: ...
+    @property
+    def lastrowid(self) -> int | None: ...
+
+
+class ConnectionABC(Protocol):
+    def cursor(self) -> CursorABC: ...
+    def commit(self) -> None: ...
+    def rollback(self) -> None: ...
+    def close(self) -> None: ...
+
+
+class CursorAsyncABC(Protocol):
+    async def execute(
+        self,
+        operation: str | Composable,
+        parameters: Sequence[Any] | None = None,
+    ) -> None: ...
+    async def executemany(
+        self,
+        operation: str | Composable,
+        seq_of_parameters: Sequence[Sequence[Any]],
+    ) -> None: ...
+    async def fetchone(self) -> Row | None: ...
+    async def fetchmany(self, size: int | None = None) -> list[Row]: ...
+    async def fetchall(self) -> list[Row]: ...
+    async def close(self) -> None: ...
+    def setinputsizes(self, sizes: Sequence[Any]) -> None: ...
+    def setoutputsize(self, size: Any, column: Any = None) -> None: ...
+
+    @property
+    def rowcount(self) -> int | Literal[-1]: ...
+    @property
+    def lastrowid(self) -> int | None: ...
+
+
+class ConnectionAsyncABC(Protocol):
+    async def cursor(self) -> CursorAsyncABC: ...
+    async def commit(self) -> None: ...
+    async def rollback(self) -> None: ...
+    async def close(self) -> None: ...

{database_wrapper-0.1.44 → database_wrapper-0.1.72}/database_wrapper/config.py

@@ -3,7 +3,7 @@ from typing import Any
 CONFIG: dict[str, Any] = {
     # These are supposed to be set automatically by a git pre-compile script
     # They are one git commit hash behind, if used automatically
-    "git_commit_hash": "ec2eca45cd9798f0c045418602fbe07ed7734848",
-    "git_commit_date": "15.11.2024 18:06",
-    "app_version": "0.1.44",
+    "git_commit_hash": "943e0234156c4a164061e5af9fb9dbd8c3041f6f",
+    "git_commit_date": "26.11.2024 22:09",
+    "app_version": "0.1.72",
 }

{database_wrapper-0.1.44 → database_wrapper-0.1.72}/database_wrapper/db_backend.py

@@ -5,63 +5,114 @@ from typing import Any
 from threading import Event
 from contextvars import ContextVar
 
-from .utils.timer import Timer
-
 
 class DatabaseBackend:
+    config: Any
+    """ Database configuration """
+
+    connectionTimeout: int
+    """ Connection timeout """
+
+    name: str
+    """ Instance name """
+
+    # TODO: This should be made to increase exponentially
+    slowDownTimeout: int
+    """ How long to wait before trying to reconnect """
+
+    pool: Any
+    """ Connection pool """
+
+    poolAsync: Any
+    """ Async connection pool """
+
     connection: Any
+    """ Connection to database """
+
     cursor: Any
+    """ Cursor to database """
+
     contextConnection: ContextVar[Any | None]
-    contextAsyncConnection: ContextVar[Any | None]
+    """ Connection used in context manager """
 
-    config: Any
+    contextConnectionAsync: ContextVar[Any | None]
+    """ Connection used in async context manager """
 
-    connectionTimeout: int
-    slowDownTimeout: int = 5
+    loggerName: str
+    """ Logger name """
 
-    name: str
     logger: logging.Logger
-    timer: ContextVar[Timer | None]
+    """ Logger """
 
     shutdownRequested: Event
+    """
+    Event to signal shutdown
+    Used to stop database pool from creating new connections
+    """
+
+    ########################
+    ### Class Life Cycle ###
+    ########################
 
     def __init__(
         self,
         dbConfig: Any,
         connectionTimeout: int = 5,
         instanceName: str = "database_backend",
+        slowDownTimeout: int = 5,
     ) -> None:
         """
         Main concept here is that in init we do not connect to database,
         so that class instances can be safely made regardless of connection statuss.
 
-        Remember to call open() before using this class.
+        Remember to call open() or openPool() before using this class.
         Close will be called automatically when class is destroyed.
-        But sometimes in async environment you should call close() proactively.
+
+        Contexts are not implemented here, but in child classes should be used
+        by using connection pooling.
+
+        Async classes should be called manually and should override __del__ method,
+        if not upon destroying the class, an error will be raised that method was not awaited.
         """
 
         self.config = dbConfig
         self.connectionTimeout = connectionTimeout
         self.name = instanceName
+        self.slowDownTimeout = slowDownTimeout
+
+        self.loggerName = f"{__name__}.{self.__class__.__name__}.{self.name}"
+        self.logger = logging.getLogger(self.loggerName)
 
-        loggerName = f"{__name__}.{self.__class__.__name__}.{self.name}"
-        self.logger = logging.getLogger(loggerName)
-        self.timer = ContextVar(f"db_timer", default=None)
+        self.pool = None
+        self.poolAsync = None
 
         self.connection = None
         self.cursor = None
         self.shutdownRequested = Event()
         self.contextConnection = ContextVar(f"db_connection_{self.name}", default=None)
-        self.contextAsyncConnection = ContextVar(
+        self.contextConnectionAsync = ContextVar(
             f"db_connection_{self.name}_async", default=None
         )
 
     def __del__(self) -> None:
         """What to do when class is destroyed"""
         self.logger.debug("Dealloc")
+
+        # Clean up connections
         self.close()
+        self.closePool()
+
+        # Clean just in case
+        del self.connection
+        del self.cursor
+
+        del self.pool
+        del self.poolAsync
+
+    ###############
+    ### Context ###
+    ###############
 
-    # Context
     def __enter__(self) -> tuple[Any, Any]:
         """Context manager"""
         raise Exception("Not implemented")
@@ -78,16 +129,23 @@ class DatabaseBackend:
         """Context manager"""
         raise Exception("Not implemented")
 
-    # Connection
-    def open(self) -> None:
-        """Connect to database"""
-        raise Exception("Not implemented")
+    ##################
+    ### Connection ###
+    ##################
+
+    def openPool(self) -> Any:
+        """Open connection pool"""
+        ...
 
-    async def openAsync(self) -> None:
+    def closePool(self) -> Any:
+        """Close connection pool"""
+        ...
+
+    def open(self) -> Any:
         """Connect to database"""
-        raise Exception("Not implemented")
+        ...
 
-    def close(self) -> None:
+    def close(self) -> Any:
         """Close connections"""
         if self.cursor:
             self.logger.debug("Closing cursor")
@@ -99,7 +157,34 @@ class DatabaseBackend:
             self.connection.close()
             self.connection = None
 
-    def fixSocketTimeouts(self, fd: Any):
+    def newConnection(self) -> Any:
+        """
+        Create new connection
+
+        Used for async context manager and async connection creation
+
+        Returns:
+            tuple[Any, Any] | None: Connection and cursor
+        """
+        raise Exception("Not implemented")
+
+    def returnConnection(self, connection: Any) -> Any:
+        """
+        Return connection to pool
+
+        Used for async context manager and async connections return.
+        For example to return connection to a pool.
+
+        Args:
+            connection (Any): Connection to return to pool
+        """
+        raise Exception("Not implemented")
+
+    ###############
+    ### Helpers ###
+    ###############
+
+    def fixSocketTimeouts(self, fd: Any) -> None:
         # Lets do some socket magic
         s = socket.fromfd(fd, socket.AF_INET, socket.SOCK_STREAM)
         # Enable sending of keep-alive messages
@@ -118,32 +203,36 @@ class DatabaseBackend:
             socket.IPPROTO_TCP, socket.TCP_USER_TIMEOUT, self.connectionTimeout * 1000
         )
 
-    async def newConnection(
-        self,
-    ) -> tuple[Any, Any] | None:
-        """
-        Create new connection
+    ####################
+    ### Transactions ###
+    ####################
 
-        Used for async context manager and async connection creation
+    def beginTransaction(self) -> Any:
+        """Start transaction"""
+        raise Exception("Not implemented")
 
-        Returns:
-            tuple[Any, Any] | None: Connection and cursor
-        """
+    def commitTransaction(self) -> Any:
+        """Commit transaction"""
         raise Exception("Not implemented")
 
-    async def returnConnection(self, connection: Any) -> None:
-        """
-        Return connection to pool
+    def rollbackTransaction(self) -> Any:
+        """Rollback transaction"""
+        raise Exception("Not implemented")
 
-        Used for async context manager and async connections return.
-        For example to return connection to a pool.
+    # @contextmanager
+    def transaction(self, dbConn: Any = None) -> Any:
+        """
+        Transaction context manager
 
-        Args:
-            connection (Any): Connection to return to pool
+        ! When overriding this method, remember to use context manager.
+        ! Its not defined here, so that it can be used in both sync and async methods.
         """
         raise Exception("Not implemented")
 
-    # Data
+    ############
+    ### Data ###
+    ############
+
     def lastInsertId(self) -> int:
         """Get last inserted row id generated by auto increment"""
         raise Exception("Not implemented")
@@ -152,10 +241,10 @@ class DatabaseBackend:
         """Get affected rows count"""
         raise Exception("Not implemented")
 
-    def commit(self) -> None:
+    def commit(self) -> Any:
         """Commit DB queries"""
         raise Exception("Not implemented")
 
-    def rollback(self) -> None:
+    def rollback(self) -> Any:
         """Rollback DB queries"""
         raise Exception("Not implemented")