database-wrapper 0.1.86__py3-none-any.whl → 0.2.4__py3-none-any.whl

database_wrapper/db_wrapper_mixin.py

@@ -10,7 +10,7 @@ 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 dbCursor: Database cursor object.
+    :property db_cursor: Database cursor object.
     :property logger: Logger object
     """
 
@@ -18,7 +18,7 @@ class DBWrapperMixin:
     ### Instance properties ###
     ###########################
 
-    dbCursor: Any
+    db_cursor: Any
     """
     Database cursor object.
     """
@@ -34,7 +34,7 @@ class DBWrapperMixin:
     # Meta methods
     def __init__(
         self,
-        dbCursor: Any = None,
+        db_cursor: Any = None,
         logger: logging.Logger | None = None,
     ) -> None:
         """
@@ -44,11 +44,11 @@ class DBWrapperMixin:
             db (DatabaseBackend): The DatabaseBackend object.
             logger (logging.Logger, optional): The logger object. Defaults to None.
         """
-        self.dbCursor = dbCursor
+        self.db_cursor = db_cursor
 
         if logger is None:
-            loggerName = f"{__name__}.{self.__class__.__name__}"
-            self.logger = logging.getLogger(loggerName)
+            logger_name = f"{__name__}.{self.__class__.__name__}"
+            self.logger = logging.getLogger(logger_name)
         else:
             self.logger = logger
 
@@ -59,32 +59,32 @@ class DBWrapperMixin:
         self.logger.debug("Dealloc")
 
         # Force remove instances so that there are no circular references
-        if hasattr(self, "dbCursor") and self.dbCursor:
-            del self.dbCursor
+        if hasattr(self, "db_cursor") and self.db_cursor:
+            del self.db_cursor
 
     ###############
     ### Setters ###
     ###############
 
-    def setDbCursor(self, dbCursor: Any) -> None:
+    def set_db_cursor(self, db_cursor: Any) -> None:
         """
         Updates the database cursor object.
 
         Args:
-            dbCursor (Any): The new database cursor object.
+            db_cursor (Any): The new database cursor object.
         """
 
-        if dbCursor is None:
-            del self.dbCursor
+        if db_cursor is None:
+            del self.db_cursor
             return
 
-        self.dbCursor = dbCursor
+        self.db_cursor = db_cursor
 
     ######################
     ### Helper methods ###
     ######################
 
-    def makeIdentifier(self, schema: str | None, name: str) -> Any:
+    def make_identifier(self, schema: str | None, name: str) -> Any:
         """
         Creates a SQL identifier object from the given name.
 
@@ -100,7 +100,7 @@ class DBWrapperMixin:
 
         return name
 
-    def logQuery(self, cursor: Any, query: Any, params: tuple[Any, ...]) -> None:
+    def log_query(self, cursor: Any, query: Any, params: tuple[Any, ...]) -> None:
         """
         Logs the given query and parameters.
 
@@ -111,10 +111,10 @@ class DBWrapperMixin:
         """
         logging.getLogger().debug(f"Query: {query} with params: {params}")
 
-    def turnDataIntoModel(
+    def turn_data_into_model(
         self,
-        emptyDataClass: Type[DataModelType],
-        dbData: dict[str, Any],
+        empty_data_class: Type[DataModelType],
+        db_data: dict[str, Any],
     ) -> DataModelType:
         """
         Turns the given data into a data model.
@@ -122,20 +122,20 @@ class DBWrapperMixin:
         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.
+            empty_data_class (DataModelType): The data model to use.
+            db_data (dict[str, Any]): The data to turn into a model.
 
         Returns:
             DataModelType: The data model filled with data.
         """
 
-        result = emptyDataClass()
-        result.fillDataFromDict(dbData)
-        result.raw_data = dbData
+        result = empty_data_class()
+        result.fill_data_from_dict(db_data)
+        result.raw_data = db_data
 
         # 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)
+        if result.id_key != "id":
+            result.id = db_data.get(result.id_key, None)
 
         return result
 
@@ -143,40 +143,40 @@ class DBWrapperMixin:
     ### Query methods ###
     #####################
 
-    def filterQuery(self, schemaName: str | None, tableName: str) -> Any:
+    def filter_query(self, schema_name: str | None, table_name: 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.
+            schema_name (str | None): The name of the schema to filter data from.
+            table_name (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}"
+        full_table_name = self.make_identifier(schema_name, table_name)
+        return f"SELECT * FROM {full_table_name}"
 
-    def orderQuery(self, orderBy: OrderByItem | None = None) -> Any | None:
+    def order_query(self, order_by: 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.
+            order_by (OrderByItem | None, optional): The column to order the results by. Defaults to None.
 
         Returns:
             Any: The created SQL query object.
         """
-        if orderBy is None:
+        if order_by is None:
             return None
 
-        orderList = [
+        order_list = [
             f"{item[0]} {item[1] if len(item) > 1 and item[1] != None else 'ASC'}"
-            for item in orderBy
+            for item in order_by
         ]
-        return "ORDER BY %s" % ", ".join(orderList)
+        return "ORDER BY %s" % ", ".join(order_list)
 
-    def limitQuery(self, offset: int = 0, limit: int = 100) -> Any | None:
+    def limit_query(self, offset: int = 0, limit: int = 100) -> Any | None:
         """
         Creates a SQL query to limit the number of results returned.
 
@@ -192,7 +192,7 @@ class DBWrapperMixin:
 
         return f"LIMIT {limit} OFFSET {offset}"
 
-    def formatFilter(self, key: str, filter: Any) -> tuple[Any, ...]:
+    def format_filter(self, key: str, filter: Any) -> tuple[Any, ...]:
         if type(filter) is dict:
             if "$contains" in filter:
                 return (
@@ -210,15 +210,15 @@ class DBWrapperMixin:
             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
-                )
+                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)
             elif "$not_in" in filter:
-                inFilter2: list[Any] = cast(list[Any], filter["$in"])
+                in_filter_2: list[Any] = cast(list[Any], filter["$in"])
                 return (
-                    f"{key} NOT IN (%s)" % ",".join(["%s"] * len(inFilter2)),
-                ) + tuple(inFilter2)
+                    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
 
@@ -248,65 +248,65 @@ class DBWrapperMixin:
                 f"Filter type not supported: {key} = {type(filter)}"
             )
 
-    def createFilter(
+    def create_filter(
         self, filter: dict[str, Any] | None
     ) -> tuple[Any, tuple[Any, ...]]:
         if filter is None or len(filter) == 0:
             return ("", tuple())
 
-        raw = [self.formatFilter(key, filter[key]) for key in filter]
+        raw = [self.format_filter(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(
+    def _format_filter_query(
         self,
         query: Any,
-        qFilter: Any,
+        q_filter: Any,
         order: Any,
         limit: Any,
     ) -> Any:
-        if qFilter is None:
-            qFilter = ""
+        if q_filter is None:
+            q_filter = ""
         if order is None:
             order = ""
         if limit is None:
             limit = ""
-        return f"{query} {qFilter} {order} {limit}"
+        return f"{query} {q_filter} {order} {limit}"
 
-    def _formatInsertQuery(
+    def _format_insert_query(
         self,
-        tableIdentifier: Any,
-        storeData: dict[str, Any],
-        returnKey: Any,
+        table_identifier: Any,
+        store_data: dict[str, Any],
+        return_key: Any,
     ) -> Any:
-        keys = storeData.keys()
-        values = list(storeData.values())
+        keys = store_data.keys()
+        values = list(store_data.values())
 
         columns = ", ".join(keys)
-        valuesPlaceholder = ", ".join(["%s"] * len(values))
+        values_placeholder = ", ".join(["%s"] * len(values))
         return (
-            f"INSERT INTO {tableIdentifier} "
+            f"INSERT INTO {table_identifier} "
             f"({columns}) "
-            f"VALUES ({valuesPlaceholder}) "
-            f"RETURNING {returnKey}"
+            f"VALUES ({values_placeholder}) "
+            f"RETURNING {return_key}"
         )
 
-    def _formatUpdateQuery(
+    def _format_update_query(
         self,
-        tableIdentifier: Any,
-        updateKey: Any,
-        updateData: dict[str, Any],
+        table_identifier: Any,
+        update_key: Any,
+        update_data: dict[str, Any],
     ) -> Any:
-        keys = updateData.keys()
+        keys = update_data.keys()
         set_clause = ", ".join(f"{key} = %s" for key in keys)
-        return f"UPDATE {tableIdentifier} SET {set_clause} WHERE {updateKey} = %s"
+        return f"UPDATE {table_identifier} SET {set_clause} WHERE {update_key} = %s"
 
-    def _formatDeleteQuery(
+    def _format_delete_query(
         self,
-        tableIdentifier: Any,
-        deleteKey: Any,
+        table_identifier: Any,
+        delete_key: Any,
     ) -> Any:
-        return f"DELETE FROM {tableIdentifier} WHERE {deleteKey} = %s"
+        return f"DELETE FROM {table_identifier} WHERE {delete_key} = %s"

database_wrapper/serialization.py

@@ -12,7 +12,7 @@ class SerializeType(Enum):
     ENUM = "enum"
 
 
-def jsonEncoder(obj: Any) -> Any:
+def json_encoder(obj: Any) -> Any:
     if isinstance(obj, Decimal):
         return float(obj)
 
@@ -28,27 +28,27 @@ def jsonEncoder(obj: Any) -> Any:
     return str(obj)
 
 
-def serializeValue(value: Any, sType: SerializeType) -> Any:
-    if sType == SerializeType.DATETIME:
+def serialize_value(value: Any, s_type: SerializeType) -> Any:
+    if s_type == SerializeType.DATETIME:
         if not isinstance(value, datetime.datetime):
             return value
 
         return value.isoformat()
 
-    if sType == SerializeType.JSON:
-        return json.dumps(value, default=jsonEncoder)
+    if s_type == SerializeType.JSON:
+        return json.dumps(value, default=json_encoder)
 
-    if sType == SerializeType.ENUM:
+    if s_type == SerializeType.ENUM:
         return value.value
     return value
 
 
-def deserializeValue(
+def deserialize_value(
     value: Any,
-    sType: SerializeType,
-    enumClass: Type[Enum] | None = None,
+    s_type: SerializeType,
+    enum_class: Type[Enum] | None = None,
 ) -> Any:
-    if sType == SerializeType.DATETIME:
+    if s_type == SerializeType.DATETIME:
         if isinstance(value, datetime.datetime):
             return value
 
@@ -61,21 +61,19 @@ def deserializeValue(
 
         return datetime.datetime.fromisoformat(value)
 
-    if sType == SerializeType.JSON:
+    if s_type == SerializeType.JSON:
         if isinstance(value, dict) or isinstance(value, list) or value is None:
             return value  # type: ignore
 
         return json.loads(value)
 
-    if sType == SerializeType.ENUM:
-        if enumClass is None:
-            raise ValueError(
-                "enumClass (enum_class) must be provided when deserializing Enum"
-            )
+    if s_type == SerializeType.ENUM:
+        if enum_class is None:
+            raise ValueError("enum_class must be provided when deserializing Enum")
 
         if isinstance(value, Enum) or value is None:
             return value
 
-        return enumClass(value)
+        return enum_class(value)
 
     return value

database_wrapper/utils/dataclass_addons.py

@@ -9,15 +9,15 @@ def ignore_unknown_kwargs() -> Callable[[AnyDataType], AnyDataType]:
     """
 
     def decorator(cls: AnyDataType) -> AnyDataType:
-        originalInit = cls.__init__
+        original_init = cls.__init__
 
-        # @wraps(originalInit)
-        def newInit(self: Any, *args: Any, **kwargs: Any) -> None:
+        # @wraps(original_init)
+        def new_init(self: Any, *args: Any, **kwargs: Any) -> None:
             # Filter out kwargs that are not properties of the class
             valid_kwargs = {k: v for k, v in kwargs.items() if hasattr(self, k)}
-            originalInit(self, *args, **valid_kwargs)
+            original_init(self, *args, **valid_kwargs)
 
-        cls.__init__ = newInit  # type: ignore
+        cls.__init__ = new_init
         return cls
 
     return decorator

{database_wrapper-0.1.86.dist-info → database_wrapper-0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: database_wrapper
-Version: 0.1.86
+Version: 0.2.4
 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)
@@ -10,7 +10,7 @@ Project-URL: Changes, https://github.com/gintsmurans/py_database_wrapper
 Project-URL: Code, https://github.com/gintsmurans/py_database_wrapper
 Project-URL: Issue Tracker, https://github.com/gintsmurans/py_database_wrapper/issues
 Project-URL: Download, https://pypi.org/project/database_wrapper/
-Keywords: database,wrapper,python,pgsql,mysql,mssql,sqlite
+Keywords: database,wrapper,python,pgsql,mysql,mssql,sqlite,redis
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: GNU General Public License v3 (GPLv3)
@@ -33,15 +33,17 @@ 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.86; extra == "pgsql"
+Requires-Dist: database_wrapper_pgsql==0.2.4; extra == "pgsql"
 Provides-Extra: mysql
-Requires-Dist: database_wrapper_mysql==0.1.86; extra == "mysql"
+Requires-Dist: database_wrapper_mysql==0.2.4; extra == "mysql"
 Provides-Extra: mssql
-Requires-Dist: database_wrapper_mssql==0.1.86; extra == "mssql"
+Requires-Dist: database_wrapper_mssql==0.2.4; extra == "mssql"
 Provides-Extra: sqlite
-Requires-Dist: database_wrapper_sqlite==0.1.86; extra == "sqlite"
+Requires-Dist: database_wrapper_sqlite==0.2.4; extra == "sqlite"
+Provides-Extra: redis
+Requires-Dist: database_wrapper_redis==0.2.4; extra == "redis"
 Provides-Extra: all
-Requires-Dist: database_wrapper[mssql,mysql,pgsql,sqlite]; 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"
@@ -69,3 +71,4 @@ See the README.md files in the database specific packages for more information.
 * [database_wrapper_mysql](https://pypi.org/project/database_wrapper_mysql/)
 * [database_wrapper_mssql](https://pypi.org/project/database_wrapper_mssql/)
 * [database_wrapper_sqlite](https://pypi.org/project/database_wrapper_sqlite/)
+* [database_wrapper_redis](https://pypi.org/project/database_wrapper_redis/)

database_wrapper-0.2.4.dist-info/RECORD

@@ -0,0 +1,17 @@
+database_wrapper/__init__.py,sha256=p-HLz9_zByIUeAS1tVxS7ZieslsryHSLw_IKZphqB7w,1200
+database_wrapper/abc.py,sha256=JiQo6Yfv7xALrrHeICJCSgmyP2gHrp16Ov83mPBTGbE,2058
+database_wrapper/common.py,sha256=fsxe28o_4xCrotPbB274dmzQ9rOyes0sBtcHog-9RVc,258
+database_wrapper/config.py,sha256=EZvKZiKqte2N_uRJXO6yEDr5qq2Jb7UgVUuNvsGXTb0,333
+database_wrapper/db_backend.py,sha256=pV_XGu0tR5naz7Ni6BvpqcmN9U7TdQ0bRkg7YiNZlO0,7928
+database_wrapper/db_data_model.py,sha256=XCQr3Z3XMwPlISsBqjRRBSd6qt21JBN1vfJHA3S5d0A,14330
+database_wrapper/db_wrapper.py,sha256=zwaA-5BfUhBTG3eI-Im4BKztbKN0DQLg5heIR-rbQCo,14928
+database_wrapper/db_wrapper_async.py,sha256=EnF66zOJ9BEH2tQF-5v8hywEHl8KiryDM9l610ES7O0,15244
+database_wrapper/db_wrapper_mixin.py,sha256=QCB9qjWLxeFY5f2_apJVL1rtp75spvZ1HuEApBkzID8,10071
+database_wrapper/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+database_wrapper/serialization.py,sha256=ghPEWXHdr2QAQlESCVibGxg4nd6Vr2eAvjX8E5Ub4cw,2041
+database_wrapper/utils/__init__.py,sha256=uC8YaJqfyFIZIeNdTRTbZwcOUVhmnS5eyOG-9gMs70c,96
+database_wrapper/utils/dataclass_addons.py,sha256=Og98FTL8_m07AjpAsbIdSkHQO099xt9asD3W2QasypY,759
+database_wrapper-0.2.4.dist-info/METADATA,sha256=L18UTzvG-Qpj75AfrCnjb_yp5HmHpVyoGm7j2nI3Hqw,3609
+database_wrapper-0.2.4.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+database_wrapper-0.2.4.dist-info/top_level.txt,sha256=QcnS4ocJygxcKE5eoOqriuja306oVu-zJRn6yjRRhBw,17
+database_wrapper-0.2.4.dist-info/RECORD,,

{database_wrapper-0.1.86.dist-info → database_wrapper-0.2.4.dist-info}/WHEEL

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

database_wrapper-0.1.86.dist-info/RECORD

@@ -1,17 +0,0 @@
-database_wrapper/__init__.py,sha256=p-HLz9_zByIUeAS1tVxS7ZieslsryHSLw_IKZphqB7w,1200
-database_wrapper/abc.py,sha256=JiQo6Yfv7xALrrHeICJCSgmyP2gHrp16Ov83mPBTGbE,2058
-database_wrapper/common.py,sha256=fsxe28o_4xCrotPbB274dmzQ9rOyes0sBtcHog-9RVc,258
-database_wrapper/config.py,sha256=kWelGxk53aaNirxNWNFJXhT9O7zKOMM9avqAeKIe4Tw,334
-database_wrapper/db_backend.py,sha256=cMpUj-GOcrr-wVFG2ztKyTd65u50R0kmQ71Lx6GXgd0,7866
-database_wrapper/db_data_model.py,sha256=3NcxWr6Sk_Ixx1QPLWZfJLwxVqN391IZ1_K4WZMNJRE,14181
-database_wrapper/db_wrapper.py,sha256=nsFHax43Zz8L3sBih9kVlnAvZWC2hv9U7V_MICbE0RY,14353
-database_wrapper/db_wrapper_async.py,sha256=8D4Oa0F6uPdjpH-cvmUPXLmbz35NLA7oa2MShIPourc,14737
-database_wrapper/db_wrapper_mixin.py,sha256=GR6Zn-2GygzzSaFWPIqkiI6mZ8oWqKY_Sc-MeUp6SG8,9966
-database_wrapper/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-database_wrapper/serialization.py,sha256=McLVLRlJ60OI2xHwnKD-0d3qHb5U8KTpz1P19SphxL8,2068
-database_wrapper/utils/__init__.py,sha256=uC8YaJqfyFIZIeNdTRTbZwcOUVhmnS5eyOG-9gMs70c,96
-database_wrapper/utils/dataclass_addons.py,sha256=r8DD40tXA_DLMQJx62UqVaRe4Gr9BSOmChLRhxawet4,770
-database_wrapper-0.1.86.dist-info/METADATA,sha256=V4VLeqJRAQojIJa6kPfqNHOs9k5C9Db_mrzpluJAH_M,3440
-database_wrapper-0.1.86.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
-database_wrapper-0.1.86.dist-info/top_level.txt,sha256=QcnS4ocJygxcKE5eoOqriuja306oVu-zJRn6yjRRhBw,17
-database_wrapper-0.1.86.dist-info/RECORD,,