database-wrapper 0.2.14__tar.gz → 0.2.16__tar.gz

{database_wrapper-0.2.14 → database_wrapper-0.2.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: database_wrapper
-Version: 0.2.14
+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.14; extra == "pgsql"
+Requires-Dist: database_wrapper_pgsql==0.2.16; extra == "pgsql"
 Provides-Extra: mysql
-Requires-Dist: database_wrapper_mysql==0.2.14; extra == "mysql"
+Requires-Dist: database_wrapper_mysql==0.2.16; extra == "mysql"
 Provides-Extra: mssql
-Requires-Dist: database_wrapper_mssql==0.2.14; extra == "mssql"
+Requires-Dist: database_wrapper_mssql==0.2.16; extra == "mssql"
 Provides-Extra: sqlite
-Requires-Dist: database_wrapper_sqlite==0.2.14; extra == "sqlite"
+Requires-Dist: database_wrapper_sqlite==0.2.16; extra == "sqlite"
 Provides-Extra: redis
-Requires-Dist: database_wrapper_redis==0.2.14; 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.14 → database_wrapper-0.2.16}/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-0.2.14 → database_wrapper-0.2.16}/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-0.2.14 → database_wrapper-0.2.16}/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": "520e71902c6f09ba35b57fd541d2e82dc5c54478",
-    "git_commit_date": "06.01.2026 02:41",
-    "app_version": "0.2.14",
+    "git_commit_hash": "4baad61b81d9f178acd8de04c1a65f2053e06d89",
+    "git_commit_date": "09.01.2026 00:48",
+    "app_version": "0.2.16",
 }

{database_wrapper-0.2.14 → database_wrapper-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-0.2.14 → database_wrapper-0.2.16}/database_wrapper/db_data_model.py

@@ -1,11 +1,11 @@
-import re
-import json
-import datetime
 import dataclasses
-
-from dataclasses import dataclass, field, asdict
+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, Callable, ClassVar, Literal, NotRequired, Type, TypeVar, TypedDict, cast
+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,7 +151,7 @@ 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()
@@ -186,9 +186,7 @@ class DBDataModel:
         for field_name, field_obj in self.__dataclass_fields__.items():
             metadata = cast(MetadataDict, field_obj.metadata)
             assert (
-                "db_field" in metadata
-                and isinstance(metadata["db_field"], tuple)
-                and len(metadata["db_field"]) == 2
+                "db_field" in metadata and isinstance(metadata["db_field"], tuple) and len(metadata["db_field"]) == 2
             ), f"db_field metadata is not set for {field_name}"
             field_type: str = metadata["db_field"][1]
             schema["properties"][field_name] = {"type": field_type}
@@ -255,7 +253,7 @@ class DBDataModel:
 
     def validate(self) -> Literal[True] | str:
         """
-            True if the instance is valid, otherwise an error message.
+        True if the instance is valid, otherwise an error message.
         """
         raise NotImplementedError("`validate` is not implemented")
 
@@ -291,13 +289,13 @@ class DBDataModel:
 
     def query_base(self) -> Any:
         """
-            Base query for all queries
+        Base query for all queries
         """
         return None
 
     def store_data(self) -> dict[str, Any] | None:
         """
-            Store data to database
+        Store data to database
         """
         store_data: dict[str, Any] = {}
         for field_name, field_obj in self.__dataclass_fields__.items():
@@ -321,7 +319,7 @@ class DBDataModel:
 
     def update_data(self) -> dict[str, Any] | None:
         """
-            Update data to database
+        Update data to database
         """
 
         update_data: dict[str, Any] = {}

{database_wrapper-0.2.14 → database_wrapper-0.2.16}/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-0.2.14 → database_wrapper-0.2.16}/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-0.2.14 → database_wrapper-0.2.16}/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-0.2.14 → database_wrapper-0.2.16}/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-0.2.14 → database_wrapper-0.2.16}/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-0.2.14 → database_wrapper-0.2.16}/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.14 → database_wrapper-0.2.16}/database_wrapper.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: database_wrapper
-Version: 0.2.14
+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.14; extra == "pgsql"
+Requires-Dist: database_wrapper_pgsql==0.2.16; extra == "pgsql"
 Provides-Extra: mysql
-Requires-Dist: database_wrapper_mysql==0.2.14; extra == "mysql"
+Requires-Dist: database_wrapper_mysql==0.2.16; extra == "mysql"
 Provides-Extra: mssql
-Requires-Dist: database_wrapper_mssql==0.2.14; extra == "mssql"
+Requires-Dist: database_wrapper_mssql==0.2.16; extra == "mssql"
 Provides-Extra: sqlite
-Requires-Dist: database_wrapper_sqlite==0.2.14; extra == "sqlite"
+Requires-Dist: database_wrapper_sqlite==0.2.16; extra == "sqlite"
 Provides-Extra: redis
-Requires-Dist: database_wrapper_redis==0.2.14; 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.14 → database_wrapper-0.2.16}/database_wrapper.egg-info/requires.txt

@@ -6,8 +6,8 @@ database_wrapper[mssql,mysql,pgsql,redis,sqlite]
 ast-comments>=1.1.2
 codespell>=2.2
 build>=1.2.1
-black>=24.1.0
-mypy>=1.9.0
+pyrefly
+ruff
 types-setuptools>=61.0.0
 types-pymssql>=2.1.0
 types-mysqlclient>=2.2.0
@@ -17,16 +17,16 @@ mysqlclient>=2.2.2
 pymssql>=2.2.10
 
 [mssql]
-database_wrapper_mssql==0.2.14
+database_wrapper_mssql==0.2.16
 
 [mysql]
-database_wrapper_mysql==0.2.14
+database_wrapper_mysql==0.2.16
 
 [pgsql]
-database_wrapper_pgsql==0.2.14
+database_wrapper_pgsql==0.2.16
 
 [redis]
-database_wrapper_redis==0.2.14
+database_wrapper_redis==0.2.16
 
 [sqlite]
-database_wrapper_sqlite==0.2.14
+database_wrapper_sqlite==0.2.16

{database_wrapper-0.2.14 → database_wrapper-0.2.16}/pyproject.toml

@@ -4,14 +4,12 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "database_wrapper"
-version = "0.2.14"
+version = "0.2.16"
 description = "A Different Approach to Database Wrappers in Python"
 readme = "README.md"
 requires-python = ">=3.8"
-license = {text = "GNU General Public License v3.0 (GPL-3.0)"}
-authors = [
-    {name = "Gints Murans", email = "gm@gm.lv"}
-]
+license = { text = "GNU General Public License v3.0 (GPL-3.0)" }
+authors = [{ name = "Gints Murans", email = "gm@gm.lv" }]
 classifiers = [
     "Development Status :: 4 - Beta",
     "Intended Audience :: Developers",
@@ -31,9 +29,18 @@ classifiers = [
     "Topic :: Database",
     "Topic :: Database :: Front-Ends",
     "Topic :: Software Development",
-    "Topic :: Software Development :: Libraries :: Python Modules"
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+keywords = [
+    "database",
+    "wrapper",
+    "python",
+    "pgsql",
+    "mysql",
+    "mssql",
+    "sqlite",
+    "redis",
 ]
-keywords = ["database", "wrapper", "python", "pgsql", "mysql", "mssql", "sqlite", "redis"]
 dependencies = []
 
 [project.urls]
@@ -45,28 +52,32 @@ Code = "https://github.com/gintsmurans/py_database_wrapper"
 Download = "https://pypi.org/project/database_wrapper/"
 
 [project.optional-dependencies]
-pgsql = ["database_wrapper_pgsql == 0.2.14"]
-mysql = ["database_wrapper_mysql == 0.2.14"]
-mssql = ["database_wrapper_mssql == 0.2.14"]
-sqlite = ["database_wrapper_sqlite == 0.2.14"]
-redis = ["database_wrapper_redis == 0.2.14"]
+pgsql = ["database_wrapper_pgsql == 0.2.16"]
+mysql = ["database_wrapper_mysql == 0.2.16"]
+mssql = ["database_wrapper_mssql == 0.2.16"]
+sqlite = ["database_wrapper_sqlite == 0.2.16"]
+redis = ["database_wrapper_redis == 0.2.16"]
 all = ["database_wrapper[pgsql,mysql,mssql,sqlite,redis]"]
 dev = [
     # Development
     "ast-comments >= 1.1.2",
     "codespell >= 2.2",
     "build >= 1.2.1",
-    # Formatting & Types
-    "black >= 24.1.0",
-    "mypy >= 1.9.0",
+
+    # Formatting
+    "pyrefly",
+    "ruff",
+
+    # Type hints
     "types-setuptools >= 61.0.0",
     "types-pymssql >= 2.1.0",
     "types-mysqlclient >= 2.2.0",
+
     # Database drivers
     "psycopg[binary] >= 3.2.0",
     "psycopg[pool] >= 3.2.0",
     "mysqlclient >= 2.2.2",
-    "pymssql >= 2.2.10"
+    "pymssql >= 2.2.10",
 ]
 
 # [tool.setuptools.packages.find]