database-wrapper 0.1.33__py3-none-any.whl → 0.1.37__py3-none-any.whl

database_wrapper/db_wrapper_mixin.py

@@ -0,0 +1,308 @@
+import logging
+
+from typing import cast, Any
+
+from .db_backend import DatabaseBackend
+from .common import OrderByItem, NoParam, DataModelType
+
+
+class DBWrapperMixin:
+    """
+    Mixin class for the DBWrapper class to provide methods that can be
+    used by both sync and async versions of the DBWrapper class.
+
+    :property db: Database backend object.
+    :property dbConn: Database connection object.
+    :property logger: Logger object
+    """
+
+    ###########################
+    ### Instance properties ###
+    ###########################
+
+    # Db backend
+    db: Any
+    """Database backend object"""
+
+    dbConn: Any
+    """
+    Database connection object.
+
+    Its not always set. Currently is used as a placeholder for async connections.
+    For sync connections db - DatabaseBackend.connection is used.
+    """
+
+    # logger
+    logger: Any
+    """Logger object"""
+
+    #######################
+    ### Class lifecycle ###
+    #######################
+
+    # Meta methods
+    def __init__(
+        self,
+        db: DatabaseBackend,
+        dbConn: Any = None,
+        logger: logging.Logger | None = None,
+    ):
+        """
+        Initializes a new instance of the DBWrapper class.
+
+        Args:
+            db (DatabaseBackend): The DatabaseBackend object.
+            logger (logging.Logger, optional): The logger object. Defaults to None.
+        """
+        self.db = db
+        self.dbConn = dbConn
+
+        if logger is None:
+            loggerName = f"{__name__}.{self.__class__.__name__}"
+            self.logger = logging.getLogger(loggerName)
+        else:
+            self.logger = logger
+
+    def __del__(self):
+        """
+        Deallocates the instance of the DBWrapper class.
+        """
+        self.logger.debug("Dealloc")
+
+        # Force remove instances so that there are no circular references
+        if hasattr(self, "db") and self.db:
+            del self.db
+
+        if hasattr(self, "dbConn") and self.dbConn:
+            del self.dbConn
+
+    ######################
+    ### Helper methods ###
+    ######################
+
+    def makeIdentifier(self, schema: str | None, name: str) -> Any:
+        """
+        Creates a SQL identifier object from the given name.
+
+        Args:
+            schema (str | None): The schema to create the identifier from.
+            name (str): The name to create the identifier from.
+
+        Returns:
+            str: The created SQL identifier object.
+        """
+        if schema:
+            return f"{schema}.{name}"
+
+        return name
+
+    def logQuery(self, cursor: Any, query: Any, params: tuple[Any, ...]) -> None:
+        """
+        Logs the given query and parameters.
+
+        Args:
+            cursor (Any): The database cursor.
+            query (Any): The query to log.
+            params (tuple[Any, ...]): The parameters to log.
+        """
+        logging.getLogger().debug(f"Query: {query} with params: {params}")
+
+    def turnDataIntoModel(
+        self,
+        emptyDataClass: DataModelType,
+        dbData: dict[str, Any],
+    ) -> DataModelType:
+        """
+        Turns the given data into a data model.
+        By default we are pretty sure that there is no factory in the cursor,
+        So we need to create a new instance of the data model and fill it with data
+
+        Args:
+            emptyDataClass (DataModelType): The data model to use.
+            dbData (dict[str, Any]): The data to turn into a model.
+
+        Returns:
+            DataModelType: The data model filled with data.
+        """
+
+        result = emptyDataClass.__class__()
+        result.fillDataFromDict(dbData)
+        result.raw_data = dbData
+
+        # If the id key is not "id", we set it manually so that its filled correctly
+        if result.idKey != "id":
+            result.id = dbData.get(result.idKey, None)
+
+        return result
+
+    #####################
+    ### Query methods ###
+    #####################
+
+    def filterQuery(self, schemaName: str | None, tableName: str) -> Any:
+        """
+        Creates a SQL query to filter data from the given table.
+
+        Args:
+            schemaName (str | None): The name of the schema to filter data from.
+            tableName (str): The name of the table to filter data from.
+
+        Returns:
+            Any: The created SQL query object.
+        """
+        fullTableName = self.makeIdentifier(schemaName, tableName)
+        return f"SELECT * FROM {fullTableName}"
+
+    def orderQuery(self, orderBy: OrderByItem | None = None) -> Any | None:
+        """
+        Creates a SQL query to order the results by the given column.
+
+        Args:
+            orderBy (OrderByItem | None, optional): The column to order the results by. Defaults to None.
+
+        Returns:
+            Any: The created SQL query object.
+        """
+        if orderBy is None:
+            return None
+
+        orderList = [
+            f"{item[0]} {item[1] if len(item) > 1 and item[1] != None else 'ASC'}"
+            for item in orderBy
+        ]
+        return "ORDER BY %s" % ", ".join(orderList)
+
+    def limitQuery(self, offset: int = 0, limit: int = 100) -> Any | None:
+        """
+        Creates a SQL query to limit the number of results returned.
+
+        Args:
+            offset (int, optional): The number of results to skip. Defaults to 0.
+            limit (int, optional): The maximum number of results to return. Defaults to 100.
+
+        Returns:
+            Any: The created SQL query object.
+        """
+        if limit == 0:
+            return None
+
+        return f"LIMIT {limit} OFFSET {offset}"
+
+    def formatFilter(self, key: str, filter: Any) -> tuple[Any, ...]:
+        if type(filter) is dict:
+            if "$contains" in filter:
+                return (
+                    f"{key} LIKE %s",
+                    f"%{filter['$contains']}%",
+                )
+            elif "$starts_with" in filter:
+                return (f"{key} LIKE %s", f"{filter['$starts_with']}%")
+            elif "$ends_with" in filter:
+                return (f"{key} LIKE %s", f"%{filter['$ends_with']}")
+            elif "$min" in filter and "$max" not in filter:
+                return (f"{key} >= %s", filter["$min"])  # type: ignore
+            elif "$max" in filter and "$min" not in filter:
+                return (f"{key} <= %s", filter["$max"])  # type: ignore
+            elif "$min" in filter and "$max" in filter:
+                return (f"{key} BETWEEN %s AND %s", filter["$min"], filter["$max"])  # type: ignore
+            elif "$in" in filter:
+                inFilter1: list[Any] = cast(list[Any], filter["$in"])
+                return (f"{key} IN (%s)" % ",".join(["%s"] * len(inFilter1)),) + tuple(
+                    inFilter1
+                )
+            elif "$not_in" in filter:
+                inFilter2: list[Any] = cast(list[Any], filter["$in"])
+                return (
+                    f"{key} NOT IN (%s)" % ",".join(["%s"] * len(inFilter2)),
+                ) + tuple(inFilter2)
+            elif "$not" in filter:
+                return (f"{key} != %s", filter["$not"])  # type: ignore
+
+            elif "$gt" in filter:
+                return (f"{key} > %s", filter["$gt"])  # type: ignore
+            elif "$gte" in filter:
+                return (f"{key} >= %s", filter["$gte"])  # type: ignore
+            elif "$lt" in filter:
+                return (f"{key} < %s", filter["$lt"])  # type: ignore
+            elif "$lte" in filter:
+                return (f"{key} <= %s", filter["$lte"])  # type: ignore
+            elif "$is_null" in filter:
+                return (f"{key} IS NULL",)  # type: ignore
+            elif "$is_not_null" in filter:
+                return (f"{key} IS NOT NULL",)  # type: ignore
+
+            raise NotImplementedError("Filter type not supported")
+        elif type(filter) is str or type(filter) is int or type(filter) is float:
+            return (f"{key} = %s", filter)
+        elif type(filter) is bool:
+            return (
+                f"{key} = TRUE" if filter else f"{key} = FALSE",
+                NoParam,
+            )
+        else:
+            raise NotImplementedError(
+                f"Filter type not supported: {key} = {type(filter)}"
+            )
+
+    def createFilter(
+        self, filter: dict[str, Any] | None
+    ) -> tuple[str, tuple[Any, ...]]:
+        if filter is None or len(filter) == 0:
+            return ("", tuple())
+
+        raw = [self.formatFilter(key, filter[key]) for key in filter]
+        _query = " AND ".join([tup[0] for tup in raw])
+        _query = f"WHERE {_query}"
+        _params = tuple([val for tup in raw for val in tup[1:] if val is not NoParam])
+
+        return (_query, _params)
+
+    def _formatFilterQuery(
+        self,
+        query: Any,
+        qFilter: Any,
+        order: Any,
+        limit: Any,
+    ) -> Any:
+        if qFilter is None:
+            qFilter = ""
+        if order is None:
+            order = ""
+        if limit is None:
+            limit = ""
+        return f"{query} {qFilter} {order} {limit}"
+
+    def _formatInsertQuery(
+        self,
+        tableIdentifier: Any,
+        storeData: dict[str, Any],
+        returnKey: Any,
+    ) -> Any:
+        keys = storeData.keys()
+        values = list(storeData.values())
+
+        columns = ", ".join(keys)
+        valuesPlaceholder = ", ".join(["%s"] * len(values))
+        return (
+            f"INSERT INTO {tableIdentifier} "
+            f"({columns}) "
+            f"VALUES ({valuesPlaceholder}) "
+            f"RETURNING {returnKey}"
+        )
+
+    def _formatUpdateQuery(
+        self,
+        tableIdentifier: Any,
+        updateKey: Any,
+        updateData: dict[str, Any],
+    ) -> Any:
+        keys = updateData.keys()
+        set_clause = ", ".join(f"{key} = %s" for key in keys)
+        return f"UPDATE {tableIdentifier} SET {set_clause} WHERE {updateKey} = %s"
+
+    def _formatDeleteQuery(
+        self,
+        tableIdentifier: Any,
+        deleteKey: Any,
+    ) -> Any:
+        return f"DELETE FROM {tableIdentifier} WHERE {deleteKey} = %s"

database_wrapper/utils/dataclass_addons.py

@@ -1,14 +1,14 @@
 from typing import Any, Callable, Type, TypeVar
 
-T = TypeVar("T", bound=Type[Any])
+AnyDataType = TypeVar("AnyDataType", bound=Type[Any])
 
 
-def ignore_unknown_kwargs() -> Callable[[T], T]:
+def ignore_unknown_kwargs() -> Callable[[AnyDataType], AnyDataType]:
     """
     Class decorator factory that modifies the __init__ method to ignore unknown keyword arguments.
     """
 
-    def decorator(cls: T) -> T:
+    def decorator(cls: AnyDataType) -> AnyDataType:
         originalInit = cls.__init__
 
         # @wraps(originalInit)

{database_wrapper-0.1.33.dist-info → database_wrapper-0.1.37.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: database_wrapper
-Version: 0.1.33
+Version: 0.1.37
 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)
@@ -46,13 +46,13 @@ Requires-Dist: psycopg[pool] >=3.2.0 ; extra == 'dev'
 Requires-Dist: mysqlclient >=2.2.2 ; extra == 'dev'
 Requires-Dist: pymssql >=2.2.10 ; extra == 'dev'
 Provides-Extra: mssql
-Requires-Dist: database-wrapper-mssql ==0.1.33 ; extra == 'mssql'
+Requires-Dist: database-wrapper-mssql ==0.1.37 ; extra == 'mssql'
 Provides-Extra: mysql
-Requires-Dist: database-wrapper-mysql ==0.1.33 ; extra == 'mysql'
+Requires-Dist: database-wrapper-mysql ==0.1.37 ; extra == 'mysql'
 Provides-Extra: pgsql
-Requires-Dist: database-wrapper-pgsql ==0.1.33 ; extra == 'pgsql'
+Requires-Dist: database-wrapper-pgsql ==0.1.37 ; extra == 'pgsql'
 Provides-Extra: sqlite
-Requires-Dist: database-wrapper-sqlite ==0.1.33 ; extra == 'sqlite'
+Requires-Dist: database-wrapper-sqlite ==0.1.37 ; extra == 'sqlite'
 
 # database_wrapper
 

database_wrapper-0.1.37.dist-info/RECORD

@@ -0,0 +1,16 @@
+database_wrapper/__init__.py,sha256=amoShlhRpOhrFbGeKbdq47H5omcVRd4xWG-RUX7bdIk,830
+database_wrapper/common.py,sha256=fsxe28o_4xCrotPbB274dmzQ9rOyes0sBtcHog-9RVc,258
+database_wrapper/config.py,sha256=6Xp2QYt44wT0t1bY2-J2xx4LdExLN2Tt3pLDwBvNDxA,334
+database_wrapper/db_backend.py,sha256=iQd1yVsLumutfoOmWY-XAAiLg00_I-IueOv_RtO_7ew,5068
+database_wrapper/db_data_model.py,sha256=njef4LR7XQcTdob961t1DQ7q3i2dzfVrFyuAtD3YYwQ,12181
+database_wrapper/db_wrapper.py,sha256=9RuixREftA52pL24qYBJSmaZ2_4a9dDSUS4MUhPSrlE,17874
+database_wrapper/db_wrapper_async.py,sha256=0fFqrV8fbFOaloXOg1qQVu_xA3RRJVrrJ6rQWti1aek,18318
+database_wrapper/db_wrapper_mixin.py,sha256=YXMLPehomcG3NNE2NEcHFNuAgCF4IvAeY6YPFJbY7Ho,9987
+database_wrapper/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+database_wrapper/utils/__init__.py,sha256=mnewmY38-837VAh4f42hvpMUBVUjOLoMtIfdZBxbkg0,134
+database_wrapper/utils/dataclass_addons.py,sha256=5_ZAj8h-4RtimEM-b9lo6TXi4qYVTf7KIjTtu0jzAS4,762
+database_wrapper/utils/timer.py,sha256=ZJpVMsQ7oHHgyuqMOxVee1fZD78kcDrP4c8gHug3xGU,8927
+database_wrapper-0.1.37.dist-info/METADATA,sha256=liIL1QV89i2wUHeYplauF7TpYQomobwtRFFjBhU5E3c,3370
+database_wrapper-0.1.37.dist-info/WHEEL,sha256=a7TGlA-5DaHMRrarXjVbQagU3Man_dCnGIWMJr5kRWo,91
+database_wrapper-0.1.37.dist-info/top_level.txt,sha256=QcnS4ocJygxcKE5eoOqriuja306oVu-zJRn6yjRRhBw,17
+database_wrapper-0.1.37.dist-info/RECORD,,

{database_wrapper-0.1.33.dist-info → database_wrapper-0.1.37.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.3.0)
+Generator: setuptools (75.4.0)
 Root-Is-Purelib: true
 Tag: py3-none-any