database-wrapper 0.2.13__py3-none-any.whl → 0.2.16__py3-none-any.whl

database_wrapper/__init__.py

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

database_wrapper/abc.py

@@ -1,9 +1,9 @@
-from typing import Dict, Any, Literal
-from typing import Any, Protocol, Sequence
+from collections.abc import Sequence
+from typing import Any, Literal, Protocol
 
 from psycopg.sql import Composable
 
-Row = Dict[str, Any]
+Row = dict[str, Any]
 
 
 class CursorABC(Protocol):

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": "450d82cbaaf0997ef1aba44a809ce8358e3b1ccd",
-    "git_commit_date": "06.01.2026 04:31",
-    "app_version": "0.2.13",
+    "git_commit_hash": "4baad61b81d9f178acd8de04c1a65f2053e06d89",
+    "git_commit_date": "09.01.2026 00:48",
+    "app_version": "0.2.16",
 }

database_wrapper/db_backend.py

@@ -1,9 +1,9 @@
 import logging
 import socket
-
-from typing import Any, Coroutine
-from threading import Event
+from collections.abc import Coroutine
 from contextvars import ContextVar
+from threading import Event
+from typing import Any
 
 
 class DatabaseBackend:

database_wrapper/db_data_model.py

@@ -1,11 +1,11 @@
-from enum import Enum
-import re
-import json
-import datetime
 import dataclasses
-
-from dataclasses import dataclass, field, asdict
-from typing import Any, Callable, Literal, NotRequired, Type, TypeVar, TypedDict, cast
+import datetime
+import json
+import re
+from collections.abc import Callable
+from dataclasses import asdict, dataclass, field
+from enum import Enum
+from typing import Any, ClassVar, Literal, NotRequired, TypedDict, TypeVar, cast
 
 from .serialization import (
     SerializeType,
@@ -24,7 +24,7 @@ class MetadataDict(TypedDict):
     exclude: NotRequired[bool]
     serialize: NotRequired[Callable[[Any], Any] | SerializeType | None]
     deserialize: NotRequired[Callable[[Any], Any] | None]
-    enum_class: NotRequired[Type[Enum] | None]
+    enum_class: NotRequired[type[Enum] | None]
     timezone: NotRequired[str | datetime.tzinfo | None]
 
 
@@ -151,20 +151,21 @@ class DBDataModel:
 
     # String - representation
     def __repr__(self) -> str:
-        return "<%s %s>" % (self.__class__.__name__, self.__dict__)
+        return f"<{self.__class__.__name__} {self.__dict__}>"
 
     def __str__(self) -> str:
         return self.to_json_string()
 
-    # Dict
     def dict_filter(self, pairs: list[tuple[str, Any]]) -> dict[str, Any]:
         new_dict: dict[str, Any] = {}
-        for field in pairs:
-            class_field = self.__dataclass_fields__.get(field[0], None)
-            if class_field is not None:
-                metadata = cast(MetadataDict, class_field.metadata)
-                if not "exclude" in metadata or not metadata["exclude"]:
-                    new_dict[field[0]] = field[1]
+        for field_name, value in pairs:
+            class_field = self.__dataclass_fields__.get(field_name, None)
+            if class_field is None:
+                continue
+
+            metadata = cast(MetadataDict, class_field.metadata)
+            if not metadata.get("exclude", False):
+                new_dict[field_name] = value
 
         return new_dict
 
@@ -256,41 +257,31 @@ class DBDataModel:
         """
         raise NotImplementedError("`validate` is not implemented")
 
-    def set_store(self, field_name: str, enable: bool = True) -> None:
-        """
-        Enable/Disable storing a field (insert into database)
-        """
-        if field_name in self.__dataclass_fields__:
-            current_metadata = cast(
-                MetadataDict,
-                dict(self.__dataclass_fields__[field_name].metadata),
-            )
-            current_metadata["store"] = enable
-            self.__dataclass_fields__[field_name].metadata = current_metadata
+    ############################
+    ### Store/update policies ###
+    ############################
 
-    def set_update(self, field_name: str, enable: bool = True) -> None:
+    @classmethod
+    def _should_store(cls, field_name: str, metadata: MetadataDict) -> bool:
         """
-        Enable/Disable updating a field (update in database)
+        Decide whether this field should be included in INSERT payload.
+        Base behavior: rely on field metadata.
+        Subclasses can override.
         """
-        if field_name in self.__dataclass_fields__:
-            current_metadata = cast(
-                MetadataDict,
-                dict(self.__dataclass_fields__[field_name].metadata),
-            )
-            current_metadata["update"] = enable
-            self.__dataclass_fields__[field_name].metadata = current_metadata
+        return bool(metadata.get("store", False))
 
-    def set_exclude(self, field_name: str, enable: bool = True) -> None:
+    @classmethod
+    def _should_update(cls, field_name: str, metadata: MetadataDict) -> bool:
         """
-        Exclude a field from dict representation
+        Decide whether this field should be included in UPDATE payload.
+        Base behavior: rely on field metadata.
+        Subclasses can override.
         """
-        if field_name in self.__dataclass_fields__:
-            current_metadata = cast(
-                MetadataDict,
-                dict(self.__dataclass_fields__[field_name].metadata),
-            )
-            current_metadata["exclude"] = enable
-            self.__dataclass_fields__[field_name].metadata = current_metadata
+        return bool(metadata.get("update", False))
+
+    @classmethod
+    def _should_exclude(cls, field_name: str, metadata: MetadataDict) -> bool:
+        return bool(metadata.get("exclude", False))
 
     ########################
     ### Database methods ###
@@ -309,8 +300,8 @@ class DBDataModel:
         store_data: dict[str, Any] = {}
         for field_name, field_obj in self.__dataclass_fields__.items():
             metadata = cast(MetadataDict, field_obj.metadata)
-            if "store" in metadata and metadata["store"] == True:
-                store_data[field_name] = getattr(self, field_name)
+            if self.__class__._should_store(field_name, metadata):
+                value = getattr(self, field_name)
 
                 # If serialize is set, and serialize is a SerializeType,
                 # we use our serialization function.
@@ -319,10 +310,11 @@ class DBDataModel:
                 serialize = metadata.get("serialize", None)
                 if serialize is not None:
                     if isinstance(serialize, SerializeType):
-                        store_data[field_name] = serialize_value(store_data[field_name], serialize)
+                        value = serialize_value(value, serialize)
                     else:
-                        store_data[field_name] = serialize(store_data[field_name])
+                        value = serialize(value)
 
+                store_data[field_name] = value
         return store_data
 
     def update_data(self) -> dict[str, Any] | None:
@@ -333,8 +325,8 @@ class DBDataModel:
         update_data: dict[str, Any] = {}
         for field_name, field_obj in self.__dataclass_fields__.items():
             metadata = cast(MetadataDict, field_obj.metadata)
-            if "update" in metadata and metadata["update"] == True:
-                update_data[field_name] = getattr(self, field_name)
+            if self.__class__._should_update(field_name, metadata):
+                value = getattr(self, field_name)
 
                 # If serialize is set, and serialize is a SerializeType,
                 # we use our serialization function.
@@ -343,30 +335,37 @@ class DBDataModel:
                 serialize = metadata.get("serialize", None)
                 if serialize is not None:
                     if isinstance(serialize, SerializeType):
-                        update_data[field_name] = serialize_value(update_data[field_name], serialize)
+                        value = serialize_value(value, serialize)
                     else:
-                        update_data[field_name] = serialize(update_data[field_name])
+                        value = serialize(value)
 
+                update_data[field_name] = value
         return update_data
 
 
 @dataclass
 class DBDefaultsDataModel(DBDataModel):
     """
-    This class includes default fields for all database models.
+    DBDataModel with conventional default columns.
+    Subclasses can set `_defaults_config` to select which defaults are active.
 
     Attributes:
     - created_at (datetime.datetime): The timestamp of when the instance was created.
     - updated_at (datetime.datetime): The timestamp of when the instance was last updated.
-    - enabled (bool): Whether the instance is enabled or not.
-    - deleted (bool): Whether the instance is deleted or not.
+    - disabled_at (datetime.datetime): The timestamp of when the instance was disabled.
+    - deleted_at (datetime.datetime): The timestamp of when the instance was deleted.
+    - enabled (bool): Whether the instance is enabled or not. Deprecated.
+    - deleted (bool): Whether the instance is deleted or not. Deprecated.
     """
 
+    # Subclasses override this as a class attribute, e.g.:
+    # _defaults_config = ["created_at", "updated_at"]
+    _defaults_config: ClassVar[list[str]] = ["created_at", "updated_at", "disabled_at", "deleted_at"]
+
     ######################
     ### Default fields ###
     ######################
 
-#
     created_at: datetime.datetime = field(
         default_factory=datetime.datetime.now,
         metadata=MetadataDict(
@@ -376,9 +375,7 @@ class DBDefaultsDataModel(DBDataModel):
             serialize=SerializeType.DATETIME,
         ),
     )
-    """created_at is readonly by default and should be present in all tables"""
 
-#
     updated_at: datetime.datetime = field(
         default_factory=datetime.datetime.now,
         metadata=MetadataDict(
@@ -388,30 +385,29 @@ class DBDefaultsDataModel(DBDataModel):
             serialize=SerializeType.DATETIME,
         ),
     )
-    """updated_at should be present in all tables and is updated automatically"""
 
-# full
-    disabled_at: datetime.datetime = field(
-        default_factory=datetime.datetime.now,
+    # Important: default None, otherwise everything becomes disabled/deleted on insert.
+    disabled_at: datetime.datetime | None = field(
+        default=None,
         metadata=MetadataDict(
             db_field=("disabled_at", "timestamptz"),
-            store=False,
-            update=False,
+            store=True,
+            update=True,
             serialize=SerializeType.DATETIME,
         ),
     )
 
-#
-    deleted_at: datetime.datetime = field(
-        default_factory=datetime.datetime.now,
+    deleted_at: datetime.datetime | None = field(
+        default=None,
         metadata=MetadataDict(
             db_field=("deleted_at", "timestamptz"),
-            store=False,
-            update=False,
+            store=True,
+            update=True,
             serialize=SerializeType.DATETIME,
         ),
     )
 
+    # @deprecated
     enabled: bool = field(
         default=True,
         metadata=MetadataDict(
@@ -420,6 +416,8 @@ class DBDefaultsDataModel(DBDataModel):
             update=False,
         ),
     )
+
+    # @deprecated
     deleted: bool = field(
         default=False,
         metadata=MetadataDict(
@@ -429,85 +427,28 @@ class DBDefaultsDataModel(DBDataModel):
         ),
     )
 
-    def update_data(self) -> dict[str, Any] | None:
-        """
-        Update data to database
-        """
-
-        # Update updated_at
-        self.updated_at = datetime.datetime.now(datetime.UTC)
-
-        return super().update_data()
-
-
-@dataclass
-class DBDefaultsDataModelV2(DBDataModel):
-    """
-    This class includes default fields for all database models.
-
-    Attributes:
-    - created_at (datetime.datetime): The timestamp of when the instance was created.
-    - updated_at (datetime.datetime): The timestamp of when the instance was last updated.
-    - enabled (bool): Whether the instance is enabled or not.
-    - deleted (bool): Whether the instance is deleted or not.
-    """
-
-    ######################
-    ### Default fields ###
-    ######################
-
-#
-    created_at: datetime.datetime = field(
-        default_factory=datetime.datetime.now,
-        metadata=MetadataDict(
-            db_field=("created_at", "timestamptz"),
-            store=True,
-            update=False,
-            serialize=SerializeType.DATETIME,
-        ),
-    )
-    """created_at is readonly by default and should be present in all tables"""
-
-#
-    updated_at: datetime.datetime = field(
-        default_factory=datetime.datetime.now,
-        metadata=MetadataDict(
-            db_field=("updated_at", "timestamptz"),
-            store=True,
-            update=True,
-            serialize=SerializeType.DATETIME,
-        ),
-    )
-    """updated_at should be present in all tables and is updated automatically"""
-
-#
-    disabled_at: datetime.datetime = field(
-        default_factory=datetime.datetime.now,
-        metadata=MetadataDict(
-            db_field=("disabled_at", "timestamptz"),
-            store=True,
-            update=True,
-            serialize=SerializeType.DATETIME,
-        ),
-    )
-
-#
-    deleted_at: datetime.datetime = field(
-        default_factory=datetime.datetime.now,
-        metadata=MetadataDict(
-            db_field=("deleted_at", "timestamptz"),
-            store=True,
-            update=True,
-            serialize=SerializeType.DATETIME,
-        ),
-    )
+    ############################
+    ### Store/update policies ###
+    ############################
+
+    @classmethod
+    def _should_store(cls, field_name: str, metadata: MetadataDict) -> bool:
+        # For the 4 defaults, defer to _defaults_config.
+        if field_name in ("created_at", "updated_at", "disabled_at", "deleted_at"):
+            return field_name in cls._defaults_config
+        return super()._should_store(field_name, metadata)
+
+    @classmethod
+    def _should_update(cls, field_name: str, metadata: MetadataDict) -> bool:
+        # created_at is never updated
+        if field_name == "created_at":
+            return False
+        if field_name in ("updated_at", "disabled_at", "deleted_at"):
+            return field_name in cls._defaults_config
+        return super()._should_update(field_name, metadata)
 
     def update_data(self) -> dict[str, Any] | None:
-        """
-        Update data to database
-        """
-
-        # Update updated_at
-        self.updated_at = datetime.datetime.now(datetime.UTC)
-
+        # Always refresh updated_at if present in this model
+        if "updated_at" in self.__dataclass_fields__ and "updated_at" in self._defaults_config:
+            self.updated_at = datetime.datetime.now(datetime.UTC)
         return super().update_data()

database_wrapper/db_introspector.py

@@ -1,8 +1,9 @@
-from dataclasses import MISSING, dataclass, make_dataclass, field, fields as dc_fields
-from datetime import datetime, date
+from dataclasses import MISSING, dataclass, field, make_dataclass
+from dataclasses import fields as dc_fields
+from datetime import date, datetime
 from enum import Enum
 from pathlib import Path
-from typing import Any, Optional, Type, Union, get_origin, get_args
+from typing import Any, Union, get_args, get_origin
 
 from database_wrapper import DBDefaultsDataModel, MetadataDict, SerializeType
 
@@ -93,12 +94,12 @@ class DBIntrospector:
         self,
         table_name: str,
         *,
-        class_name: Optional[str] = None,
-        base: Type[DBDefaultsDataModel] = DBDefaultsDataModel,
-        enum_overrides: dict[str, Type[Enum]] | None = None,
+        class_name: str | None = None,
+        base: type[DBDefaultsDataModel] = DBDefaultsDataModel,
+        enum_overrides: dict[str, type[Enum]] | None = None,
         defaults_for_nullable: bool = True,
         include_id_field: bool = True,
-    ) -> Type[DBDefaultsDataModel]:
+    ) -> type[DBDefaultsDataModel]:
         (schema, table) = self.get_schema_table_name(table_name)
         cols = self.get_table_columns(schema, table)
         if not cols:
@@ -115,7 +116,7 @@ class DBIntrospector:
                 continue
 
             # Enums
-            enum_class: Optional[Type[Enum]] = None
+            enum_class: type[Enum] | None = None
             if c.enum_labels:
                 enum_class = enum_overrides.get(c.col_name)
                 if not enum_class:
@@ -127,14 +128,14 @@ class DBIntrospector:
 
             # Optional typing if nullable
             if c.is_nullable:
-                ann = Optional[py_type]  # type: ignore
+                ann: type[py_type] | None = py_type
             else:
-                ann = py_type  # type: ignore
+                ann = py_type
 
             # Default value choice
             default = None
             default_factory = None
-            if c.is_nullable == False:
+            if not c.is_nullable:
                 # give some sane defaults for common not-nullables that aren't id/serial
                 if py_type is bool:
                     default = False
@@ -156,7 +157,7 @@ class DBIntrospector:
                 elif py_type is set:
                     default_factory = set
                 elif py_type is bytes:
-                    default = bytes()
+                    default = b""
                 else:
                     # Leave unset so dataclass enforces passing it explicitly
                     default = None if defaults_for_nullable else None
@@ -202,15 +203,15 @@ class DBIntrospector:
         def _tableName(self) -> str:
             return table
 
-        setattr(cls, "schemaName", property(_schemaName))
-        setattr(cls, "tableName", property(_tableName))
+        cls.schemaName = property(_schemaName)
+        cls.tableName = property(_tableName)
 
         return cls
 
     # TODO: Need to improve handling of imports for external classes, including enums.
     def render_dataclass_source(
         self,
-        cls: Type,
+        cls: type,
         table_name: str,
         *,
         extra_imports: list[str] | None = None,
@@ -242,7 +243,7 @@ class DBIntrospector:
         dynamic_enums: list[tuple[str, list[tuple[str, Any]]]] = []
         external_enum_imports: set[tuple[str, str]] = set()
         for f in dc_fields(cls):
-            md: MetadataDict = dict(f.metadata) if f.metadata else {}  # type: ignore
+            md: MetadataDict = dict(f.metadata) if f.metadata else {}
             enum_class = md.get("enum_class")
             if enum_class:
                 mod = getattr(enum_class, "__module__", "")
@@ -250,7 +251,7 @@ class DBIntrospector:
                 # If it's the built-in Enum module (meaning we made it dynamically),
                 # embed it. Otherwise, import from its module.
                 if mod == "enum":
-                    members = [(m.name, m.value) for m in enum_class]  # type: ignore
+                    members = [(m.name, m.value) for m in enum_class]
                     dynamic_enums.append((name, members))
                 else:
                     external_enum_imports.add((mod, name))
@@ -298,7 +299,7 @@ class DBIntrospector:
 
         # Render fields (skip the inherited ones we know exist on base if they aren't present here)
         for f in dc_fields(cls):
-            md: MetadataDict = dict(f.metadata) if f.metadata else {}  # type: ignore
+            md: MetadataDict = dict(f.metadata) if f.metadata else {}
             # We always render all fields that exist in this dataclass (your make_dataclass created them)
             db_field = md.get("db_field", (f.name, "Any"))
             if not (isinstance(db_field, tuple) and len(db_field) == 2):
@@ -357,7 +358,7 @@ class DBIntrospector:
         lines.append("        out: dict[str, Any] = {}")
         lines.append("        # Explicitly list each field (stable order)")
         for f in dc_fields(cls):
-            md: MetadataDict = dict(f.metadata) if f.metadata else {}  # type: ignore
+            md: MetadataDict = dict(f.metadata) if f.metadata else {}
             serialize = md.get("serialize")
             key = f.name
             if serialize == SerializeType.DATETIME:

database_wrapper/db_wrapper.py

@@ -1,8 +1,9 @@
-from typing import Generator, Any, overload
+from collections.abc import Generator
+from typing import Any, overload
 
+from .common import DataModelType, OrderByItem
 from .db_data_model import DBDataModel
 from .db_wrapper_mixin import DBWrapperMixin
-from .common import OrderByItem, DataModelType
 
 
 class DBWrapper(DBWrapperMixin):
@@ -230,8 +231,7 @@ class DBWrapper(DBWrapperMixin):
         )
 
     @overload
-    def insert(self, records: DataModelType) -> tuple[int, int]:  # type: ignore
-        ...
+    def insert(self, records: DataModelType) -> tuple[int, int]: ...
 
     @overload
     def insert(self, records: list[DataModelType]) -> list[tuple[int, int]]: ...
@@ -335,8 +335,7 @@ class DBWrapper(DBWrapperMixin):
         return affected_rows
 
     @overload
-    def update(self, records: DataModelType) -> int:  # type: ignore
-        ...
+    def update(self, records: DataModelType) -> int: ...
 
     @overload
     def update(self, records: list[DataModelType]) -> list[int]: ...
@@ -441,8 +440,7 @@ class DBWrapper(DBWrapperMixin):
         return affected_rows
 
     @overload
-    def delete(self, records: DataModelType) -> int:  # type: ignore
-        ...
+    def delete(self, records: DataModelType) -> int: ...
 
     @overload
     def delete(self, records: list[DataModelType]) -> list[int]: ...

database_wrapper/db_wrapper_async.py

@@ -1,6 +1,7 @@
-from typing import AsyncGenerator, Any, overload
+from collections.abc import AsyncGenerator
+from typing import Any, overload
 
-from .common import OrderByItem, DataModelType
+from .common import DataModelType, OrderByItem
 from .db_data_model import DBDataModel
 from .db_wrapper_mixin import DBWrapperMixin
 
@@ -232,8 +233,7 @@ class DBWrapperAsync(DBWrapperMixin):
         )
 
     @overload
-    async def insert(self, records: DataModelType) -> tuple[int, int]:  # type: ignore
-        ...
+    async def insert(self, records: DataModelType) -> tuple[int, int]: ...
 
     @overload
     async def insert(self, records: list[DataModelType]) -> list[tuple[int, int]]: ...
@@ -336,8 +336,7 @@ class DBWrapperAsync(DBWrapperMixin):
         return affected_rows
 
     @overload
-    async def update(self, records: DataModelType) -> int:  # type: ignore
-        ...
+    async def update(self, records: DataModelType) -> int: ...
 
     @overload
     async def update(self, records: list[DataModelType]) -> list[int]: ...
@@ -442,8 +441,7 @@ class DBWrapperAsync(DBWrapperMixin):
         return affected_rows
 
     @overload
-    async def delete(self, records: DataModelType) -> int:  # type: ignore
-        ...
+    async def delete(self, records: DataModelType) -> int: ...
 
     @overload
     async def delete(self, records: list[DataModelType]) -> list[int]: ...

database_wrapper/db_wrapper_mixin.py

@@ -1,8 +1,7 @@
 import logging
+from typing import Any, cast
 
-from typing import Type, cast, Any
-
-from .common import OrderByItem, NoParam, DataModelType
+from .common import DataModelType, NoParam, OrderByItem
 
 
 class DBWrapperMixin:
@@ -113,7 +112,7 @@ class DBWrapperMixin:
 
     def turn_data_into_model(
         self,
-        empty_data_class: Type[DataModelType],
+        empty_data_class: type[DataModelType],
         db_data: dict[str, Any],
     ) -> DataModelType:
         """
@@ -170,11 +169,8 @@ class DBWrapperMixin:
         if order_by is None:
             return None
 
-        order_list = [
-            f"{item[0]} {item[1] if len(item) > 1 and item[1] != None else 'ASC'}"
-            for item in order_by
-        ]
-        return "ORDER BY %s" % ", ".join(order_list)
+        order_list = [f"{item[0]} {item[1] if len(item) > 1 and item[1] is not None else 'ASC'}" for item in order_by]
+        return "ORDER BY {}".format(", ".join(order_list))
 
     def limit_query(self, offset: int = 0, limit: int = 100) -> Any | None:
         """
@@ -204,36 +200,32 @@ class DBWrapperMixin:
             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
+                return (f"{key} >= %s", filter["$min"])
             elif "$max" in filter and "$min" not in filter:
-                return (f"{key} <= %s", filter["$max"])  # type: ignore
+                return (f"{key} <= %s", filter["$max"])
             elif "$min" in filter and "$max" in filter:
-                return (f"{key} BETWEEN %s AND %s", filter["$min"], filter["$max"])  # type: ignore
+                return (f"{key} BETWEEN %s AND %s", filter["$min"], filter["$max"])
             elif "$in" in filter:
                 in_filter_1: list[Any] = cast(list[Any], filter["$in"])
-                return (
-                    f"{key} IN (%s)" % ",".join(["%s"] * len(in_filter_1)),
-                ) + tuple(in_filter_1)
+                return (f"{key} IN (%s)" % ",".join(["%s"] * len(in_filter_1)),) + tuple(in_filter_1)
             elif "$not_in" in filter:
                 in_filter_2: list[Any] = cast(list[Any], filter["$in"])
-                return (
-                    f"{key} NOT IN (%s)" % ",".join(["%s"] * len(in_filter_2)),
-                ) + tuple(in_filter_2)
+                return (f"{key} NOT IN (%s)" % ",".join(["%s"] * len(in_filter_2)),) + tuple(in_filter_2)
             elif "$not" in filter:
-                return (f"{key} != %s", filter["$not"])  # type: ignore
+                return (f"{key} != %s", filter["$not"])
 
             elif "$gt" in filter:
-                return (f"{key} > %s", filter["$gt"])  # type: ignore
+                return (f"{key} > %s", filter["$gt"])
             elif "$gte" in filter:
-                return (f"{key} >= %s", filter["$gte"])  # type: ignore
+                return (f"{key} >= %s", filter["$gte"])
             elif "$lt" in filter:
-                return (f"{key} < %s", filter["$lt"])  # type: ignore
+                return (f"{key} < %s", filter["$lt"])
             elif "$lte" in filter:
-                return (f"{key} <= %s", filter["$lte"])  # type: ignore
+                return (f"{key} <= %s", filter["$lte"])
             elif "$is_null" in filter:
-                return (f"{key} IS NULL",)  # type: ignore
+                return (f"{key} IS NULL",)
             elif "$is_not_null" in filter:
-                return (f"{key} IS NOT NULL",)  # type: ignore
+                return (f"{key} IS NOT NULL",)
 
             raise NotImplementedError("Filter type not supported")
         elif type(filter) is str or type(filter) is int or type(filter) is float:
@@ -244,13 +236,9 @@ class DBWrapperMixin:
                 NoParam,
             )
         else:
-            raise NotImplementedError(
-                f"Filter type not supported: {key} = {type(filter)}"
-            )
+            raise NotImplementedError(f"Filter type not supported: {key} = {type(filter)}")
 
-    def create_filter(
-        self, filter: dict[str, Any] | None
-    ) -> tuple[Any, tuple[Any, ...]]:
+    def create_filter(self, filter: dict[str, Any] | None) -> tuple[Any, tuple[Any, ...]]:
         if filter is None or len(filter) == 0:
             return ("", tuple())
 
@@ -287,12 +275,7 @@ class DBWrapperMixin:
 
         columns = ", ".join(keys)
         values_placeholder = ", ".join(["%s"] * len(values))
-        return (
-            f"INSERT INTO {table_identifier} "
-            f"({columns}) "
-            f"VALUES ({values_placeholder}) "
-            f"RETURNING {return_key}"
-        )
+        return f"INSERT INTO {table_identifier} ({columns}) VALUES ({values_placeholder}) RETURNING {return_key}"
 
     def _format_update_query(
         self,

database_wrapper/serialization.py

@@ -1,9 +1,8 @@
 import datetime
 import json
-
 from decimal import Decimal
 from enum import Enum
-from typing import Any, Type
+from typing import Any
 from zoneinfo import ZoneInfo
 
 
@@ -61,7 +60,7 @@ def serialize_value(value: Any, s_type: SerializeType) -> Any:
 def deserialize_value(
     value: Any,
     s_type: SerializeType,
-    enum_class: Type[Enum] | None = None,
+    enum_class: type[Enum] | None = None,
     timezone: str | datetime.tzinfo | None = None,
 ) -> Any:
     if s_type == SerializeType.DATETIME:
@@ -95,7 +94,7 @@ def deserialize_value(
 
     if s_type == SerializeType.JSON:
         if isinstance(value, dict) or isinstance(value, list) or value is None:
-            return value  # type: ignore
+            return value
 
         return json.loads(value)
 

database_wrapper/utils/dataclass_addons.py

@@ -1,6 +1,7 @@
-from typing import Any, Callable, Type, TypeVar
+from collections.abc import Callable
+from typing import Any, TypeVar
 
-AnyDataType = TypeVar("AnyDataType", bound=Type[Any])
+AnyDataType = TypeVar("AnyDataType", bound=type[Any])
 
 
 def ignore_unknown_kwargs() -> Callable[[AnyDataType], AnyDataType]:

{database_wrapper-0.2.13.dist-info → database_wrapper-0.2.16.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: database_wrapper
-Version: 0.2.13
+Version: 0.2.16
 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,23 +33,23 @@ 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.2.13; extra == "pgsql"
+Requires-Dist: database_wrapper_pgsql==0.2.16; extra == "pgsql"
 Provides-Extra: mysql
-Requires-Dist: database_wrapper_mysql==0.2.13; extra == "mysql"
+Requires-Dist: database_wrapper_mysql==0.2.16; extra == "mysql"
 Provides-Extra: mssql
-Requires-Dist: database_wrapper_mssql==0.2.13; extra == "mssql"
+Requires-Dist: database_wrapper_mssql==0.2.16; extra == "mssql"
 Provides-Extra: sqlite
-Requires-Dist: database_wrapper_sqlite==0.2.13; extra == "sqlite"
+Requires-Dist: database_wrapper_sqlite==0.2.16; extra == "sqlite"
 Provides-Extra: redis
-Requires-Dist: database_wrapper_redis==0.2.13; extra == "redis"
+Requires-Dist: database_wrapper_redis==0.2.16; extra == "redis"
 Provides-Extra: all
 Requires-Dist: database_wrapper[mssql,mysql,pgsql,redis,sqlite]; extra == "all"
 Provides-Extra: dev
 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: pyrefly; extra == "dev"
+Requires-Dist: ruff; 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"

database_wrapper-0.2.16.dist-info/RECORD

@@ -0,0 +1,18 @@
+database_wrapper/__init__.py,sha256=aV6eFoz03yDZr-ba0O59yECowlmfNYVUkKqSE-BYz8w,1320
+database_wrapper/abc.py,sha256=zerWfTTUuYqFJoCTO4HGsCPETz0Zk4re2wKB_4x2pv4,2056
+database_wrapper/common.py,sha256=fsxe28o_4xCrotPbB274dmzQ9rOyes0sBtcHog-9RVc,258
+database_wrapper/config.py,sha256=6VYDhm4VbLAX6Owddnlj2x--z7-wC3FHStm7GVEtBVU,334
+database_wrapper/db_backend.py,sha256=2JhNlPhFfo6LeweCwIuM-SfvB1Ga9Bst4sXiUmrFKEM,7954
+database_wrapper/db_data_model.py,sha256=JhpkgBcJn1vrQG3AnjQloU7fk907wdNkTXLDug_7pGA,15590
+database_wrapper/db_introspector.py,sha256=ny6m56Izsd4LX-yUbJ0mWDA7GhjIBD8XiauxXwxzNfo,15349
+database_wrapper/db_wrapper.py,sha256=Cxl8Pw_-CRygf85h5_v-dgh5YM0MSJ-vVhTzJocNFQg,15186
+database_wrapper/db_wrapper_async.py,sha256=DQpUHwUaKVAJ11gUVSWTucsNbm2I5rx1LWRCcH1mDRc,15455
+database_wrapper/db_wrapper_mixin.py,sha256=KKsu-XGi5kxEoAZXImhQEMVCwxMivzmbTV0nxsWCQg4,9688
+database_wrapper/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+database_wrapper/serialization.py,sha256=X9N7YPZfy_D09yr61zsdgbmxUb_0cuq5Dbu8a-txd6s,2883
+database_wrapper/utils/__init__.py,sha256=uC8YaJqfyFIZIeNdTRTbZwcOUVhmnS5eyOG-9gMs70c,96
+database_wrapper/utils/dataclass_addons.py,sha256=UDztvz_UwYmZ8Jk_UzZjfy8YbwmPIutT1XzWaep-ht0,780
+database_wrapper-0.2.16.dist-info/METADATA,sha256=5BCw_Wmosf3hdyo5zryAI9H71MkFTR0UteQj-7xP8f8,3602
+database_wrapper-0.2.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+database_wrapper-0.2.16.dist-info/top_level.txt,sha256=QcnS4ocJygxcKE5eoOqriuja306oVu-zJRn6yjRRhBw,17
+database_wrapper-0.2.16.dist-info/RECORD,,

database_wrapper-0.2.13.dist-info/RECORD

@@ -1,18 +0,0 @@
-database_wrapper/__init__.py,sha256=cGqsWr7imdMOO7vrcGye8FVul_v3-32mw4wgrfxnhJA,1320
-database_wrapper/abc.py,sha256=JiQo6Yfv7xALrrHeICJCSgmyP2gHrp16Ov83mPBTGbE,2058
-database_wrapper/common.py,sha256=fsxe28o_4xCrotPbB274dmzQ9rOyes0sBtcHog-9RVc,258
-database_wrapper/config.py,sha256=y4Y2g4sEbD1kgqLNpxsfkDqXHurMFfaJQiellYs09PE,334
-database_wrapper/db_backend.py,sha256=pV_XGu0tR5naz7Ni6BvpqcmN9U7TdQ0bRkg7YiNZlO0,7928
-database_wrapper/db_data_model.py,sha256=zhD_c1H5YV2f29DjBTQ5Oln99iO8hWdtcf-ijelWQnA,17000
-database_wrapper/db_introspector.py,sha256=8sWNmBeumCE0D-cbpBvpMSTbCU6dpDLxCPB8HaNf6KA,15463
-database_wrapper/db_wrapper.py,sha256=x6xsMW0epCOaj3RWWi9mj1EE1JmqM27PyS_Khvsxdvo,15231
-database_wrapper/db_wrapper_async.py,sha256=ud7kCDfsfrbp3FHfRS7FjbsVTnnf87sHsxctpNWuhnk,15500
-database_wrapper/db_wrapper_mixin.py,sha256=QCB9qjWLxeFY5f2_apJVL1rtp75spvZ1HuEApBkzID8,10071
-database_wrapper/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-database_wrapper/serialization.py,sha256=Tti1-nA7H4g3hzqr3mE2WurxOnEjFaxBJZTOR3ONZSo,2906
-database_wrapper/utils/__init__.py,sha256=uC8YaJqfyFIZIeNdTRTbZwcOUVhmnS5eyOG-9gMs70c,96
-database_wrapper/utils/dataclass_addons.py,sha256=Og98FTL8_m07AjpAsbIdSkHQO099xt9asD3W2QasypY,759
-database_wrapper-0.2.13.dist-info/METADATA,sha256=sD36XRl-81M6pJOM8QESSUVgQd7SrkPg4n9Bfvms1Pw,3615
-database_wrapper-0.2.13.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-database_wrapper-0.2.13.dist-info/top_level.txt,sha256=QcnS4ocJygxcKE5eoOqriuja306oVu-zJRn6yjRRhBw,17
-database_wrapper-0.2.13.dist-info/RECORD,,