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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: database_wrapper_pgsql
-Version: 0.2.14
+Version: 0.2.16
 Summary: database_wrapper for PostgreSQL database
 Author-email: Gints Murans <gm@gm.lv>
 License: GNU General Public License v3.0 (GPL-3.0)
@@ -32,7 +32,7 @@ Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: database_wrapper==0.2.14
+Requires-Dist: database_wrapper==0.2.16
 Requires-Dist: psycopg[binary]>=3.2.0
 Requires-Dist: psycopg[pool]>=3.2.0
 

{database_wrapper_pgsql-0.2.14 → database_wrapper_pgsql-0.2.16}/database_wrapper_pgsql/connector.py

@@ -1,22 +1,16 @@
+from collections.abc import AsyncIterator, Iterator
 from contextlib import asynccontextmanager, contextmanager
 from contextvars import ContextVar
-from typing import Any, AsyncIterator, Iterator, NotRequired, TypedDict, cast
-
-from psycopg import (
-    # Async
-    AsyncConnection as PgConnectionAsync,
-    AsyncCursor as PgCursorAsync,
-    AsyncTransaction,
-    # Sync
-    Connection as PgConnection,
-    Cursor as PgCursor,
-    Transaction,
-)
-from psycopg.rows import (
-    DictRow as PgDictRow,
-    dict_row as PgDictRowFactory,
-)
-from psycopg_pool import ConnectionPool, AsyncConnectionPool
+from typing import Any, NotRequired, TypedDict, cast
+
+from psycopg import AsyncConnection as PgConnectionAsync  # Async
+from psycopg import AsyncCursor as PgCursorAsync
+from psycopg import AsyncTransaction, Transaction
+from psycopg import Connection as PgConnection  # Sync
+from psycopg import Cursor as PgCursor
+from psycopg.rows import DictRow as PgDictRow
+from psycopg.rows import dict_row as PgDictRowFactory
+from psycopg_pool import AsyncConnectionPool, ConnectionPool
 
 from database_wrapper import DatabaseBackend
 
@@ -97,7 +91,7 @@ class PgSQL(DatabaseBackend):
                 password=self.config["password"],
                 dbname=self.config["database"],
                 connect_timeout=self.connection_timeout,
-                row_factory=PgDictRowFactory,  # type: ignore
+                row_factory=PgDictRowFactory,
                 **self.config["kwargs"],
             ),
         )
@@ -147,14 +141,14 @@ class PgSQL(DatabaseBackend):
         """Commit DB queries"""
         assert self.connection, "Connection is not initialized"
 
-        self.logger.debug(f"Commit DB queries")
+        self.logger.debug("Commit DB queries")
         self.connection.commit()
 
     def rollback(self) -> None:
         """Rollback DB queries"""
         assert self.connection, "Connection is not initialized"
 
-        self.logger.debug(f"Rollback DB queries")
+        self.logger.debug("Rollback DB queries")
         self.connection.rollback()
 
 
@@ -216,7 +210,7 @@ class PgSQLAsync(DatabaseBackend):
             password=self.config["password"],
             dbname=self.config["database"],
             connect_timeout=self.connection_timeout,
-            row_factory=PgDictRowFactory,  # type: ignore
+            row_factory=PgDictRowFactory,
             **self.config["kwargs"],
         )
         self.cursor = self.connection.cursor(row_factory=PgDictRowFactory)
@@ -275,14 +269,14 @@ class PgSQLAsync(DatabaseBackend):
         """Commit DB queries"""
         assert self.connection, "Connection is not initialized"
 
-        self.logger.debug(f"Commit DB queries")
+        self.logger.debug("Commit DB queries")
         await self.connection.commit()
 
     async def rollback(self) -> None:
         """Rollback DB queries"""
         assert self.connection, "Connection is not initialized"
 
-        self.logger.debug(f"Rollback DB queries")
+        self.logger.debug("Rollback DB queries")
         await self.connection.rollback()
 
 
@@ -352,23 +346,23 @@ class PgSQLWithPooling(DatabaseBackend):
         super().__init__(db_config, connection_timeout, instance_name)
 
         # Set defaults
-        if not "port" in self.config or not self.config["port"]:
+        if "port" not in self.config or not self.config["port"]:
             self.config["port"] = 5432
 
-        if not "ssl" in self.config or not self.config["ssl"]:
+        if "ssl" not in self.config or not self.config["ssl"]:
             self.config["ssl"] = "prefer"
 
-        if not "kwargs" in self.config or not self.config["kwargs"]:
+        if "kwargs" not in self.config or not self.config["kwargs"]:
             self.config["kwargs"] = {}
 
-        if not "autocommit" in self.config["kwargs"]:
+        if "autocommit" not in self.config["kwargs"]:
             self.config["kwargs"]["autocommit"] = True
 
         # Connection pooling defaults
-        if not "maxconnections" in self.config or not self.config["maxconnections"]:
+        if "maxconnections" not in self.config or not self.config["maxconnections"]:
             self.config["maxconnections"] = 5
 
-        if not "pool_kwargs" in self.config or not self.config["pool_kwargs"]:
+        if "pool_kwargs" not in self.config or not self.config["pool_kwargs"]:
             self.config["pool_kwargs"] = {}
 
         conn_str = (
@@ -536,14 +530,14 @@ class PgSQLWithPooling(DatabaseBackend):
         """Commit DB queries"""
         assert self.connection, "Connection is not initialized"
 
-        self.logger.debug(f"Commit DB queries")
+        self.logger.debug("Commit DB queries")
         self.connection.commit()
 
     def rollback(self) -> None:
         """Rollback DB queries"""
         assert self.connection, "Connection is not initialized"
 
-        self.logger.debug(f"Rollback DB queries")
+        self.logger.debug("Rollback DB queries")
         self.connection.rollback()
 
 
@@ -594,9 +588,7 @@ class PgSQLWithPoolingAsync(DatabaseBackend):
     cursor: PgCursorTypeAsync | None
     """ Cursor to database """
 
-    context_connection_async: ContextVar[
-        tuple[PgConnectionTypeAsync, PgCursorTypeAsync] | None
-    ]
+    context_connection_async: ContextVar[tuple[PgConnectionTypeAsync, PgCursorTypeAsync] | None]
     """ Connection used in async context manager """
 
     ########################
@@ -620,23 +612,23 @@ class PgSQLWithPoolingAsync(DatabaseBackend):
         super().__init__(db_config, connection_timeout, instance_name)
 
         # Set defaults
-        if not "port" in self.config or not self.config["port"]:
+        if "port" not in self.config or not self.config["port"]:
             self.config["port"] = 5432
 
-        if not "ssl" in self.config or not self.config["ssl"]:
+        if "ssl" not in self.config or not self.config["ssl"]:
             self.config["ssl"] = "prefer"
 
-        if not "kwargs" in self.config or not self.config["kwargs"]:
+        if "kwargs" not in self.config or not self.config["kwargs"]:
             self.config["kwargs"] = {}
 
-        if not "autocommit" in self.config["kwargs"]:
+        if "autocommit" not in self.config["kwargs"]:
             self.config["kwargs"]["autocommit"] = True
 
         # Connection pooling defaults
-        if not "maxconnections" in self.config or not self.config["maxconnections"]:
+        if "maxconnections" not in self.config or not self.config["maxconnections"]:
             self.config["maxconnections"] = 5
 
-        if not "pool_kwargs" in self.config or not self.config["pool_kwargs"]:
+        if "pool_kwargs" not in self.config or not self.config["pool_kwargs"]:
             self.config["pool_kwargs"] = {}
 
         conn_str = (
@@ -720,9 +712,7 @@ class PgSQLWithPoolingAsync(DatabaseBackend):
         while not self.shutdown_requested.is_set():
             connection = None
             try:
-                connection = await self.pool_async.getconn(
-                    timeout=self.connection_timeout
-                )
+                connection = await self.pool_async.getconn(timeout=self.connection_timeout)
                 cursor = connection.cursor(row_factory=PgDictRowFactory)
 
                 # Lets do some socket magic
@@ -824,12 +814,12 @@ class PgSQLWithPoolingAsync(DatabaseBackend):
         """Commit DB queries"""
         assert self.connection, "Connection is not initialized"
 
-        self.logger.debug(f"Commit DB queries")
+        self.logger.debug("Commit DB queries")
         await self.connection.commit()
 
     async def rollback(self) -> None:
         """Rollback DB queries"""
         assert self.connection, "Connection is not initialized"
 
-        self.logger.debug(f"Rollback DB queries")
+        self.logger.debug("Rollback DB queries")
         await self.connection.rollback()

{database_wrapper_pgsql-0.2.14 → database_wrapper_pgsql-0.2.16}/database_wrapper_pgsql/db_wrapper_pgsql.py

@@ -2,10 +2,11 @@ import logging
 from typing import Any
 
 from psycopg import Cursor, sql
+
 from database_wrapper import DBWrapper
 
-from .db_wrapper_pgsql_mixin import DBWrapperPgSQLMixin
 from .connector import PgCursorType
+from .db_wrapper_pgsql_mixin import DBWrapperPgSQLMixin
 
 
 class DBWrapperPgSQL(DBWrapperPgSQLMixin, DBWrapper):

{database_wrapper_pgsql-0.2.14 → database_wrapper_pgsql-0.2.16}/database_wrapper_pgsql/db_wrapper_pgsql_async.py

@@ -2,10 +2,11 @@ import logging
 from typing import Any
 
 from psycopg import sql
+
 from database_wrapper import DBWrapperAsync
 
-from .db_wrapper_pgsql_mixin import DBWrapperPgSQLMixin
 from .connector import PgCursorTypeAsync
+from .db_wrapper_pgsql_mixin import DBWrapperPgSQLMixin
 
 
 class DBWrapperPgSQLAsync(DBWrapperPgSQLMixin, DBWrapperAsync):

{database_wrapper_pgsql-0.2.14 → database_wrapper_pgsql-0.2.16}/database_wrapper_pgsql/db_wrapper_pgsql_mixin.py

@@ -1,7 +1,8 @@
 from typing import Any
 
 from psycopg import sql
-from database_wrapper import OrderByItem, NoParam
+
+from database_wrapper import NoParam, OrderByItem
 
 
 class DBWrapperPgSQLMixin:
@@ -69,11 +70,8 @@ class DBWrapperPgSQLMixin:
         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 sql.SQL("ORDER BY %s" % ", ".join(order_list))  # type: ignore
+        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 sql.SQL("ORDER BY {}".format(", ".join(order_list)))
 
     def limit_query(
         self,
@@ -88,11 +86,9 @@ class DBWrapperPgSQLMixin:
     def format_filter(self, key: str, filter: Any) -> tuple[Any, ...]:
         # TODO: For now we assume that we have that method from DBWrapperMixin
         # TODO: Its 5am and I am tired, I will fix this later
-        return super().format_filter(key, filter)  # type: ignore
+        return super().format_filter(key, filter)
 
-    def create_filter(
-        self, filter: dict[str, Any] | None
-    ) -> tuple[sql.Composed | None, tuple[Any, ...]]:
+    def create_filter(self, filter: dict[str, Any] | None) -> tuple[sql.Composed | None, tuple[Any, ...]]:
         if filter is None or len(filter) == 0:
             return (None, tuple())
 
@@ -111,9 +107,8 @@ class DBWrapperPgSQLMixin:
         order: sql.SQL | sql.Composed | None,
         limit: sql.SQL | sql.Composed | None,
     ) -> sql.Composed:
-
         if isinstance(query, str):
-            query = sql.SQL(query)  # type: ignore
+            query = sql.SQL(query)
 
         query_parts: list[sql.Composable] = [query]
         if q_filter is not None:
@@ -136,9 +131,7 @@ class DBWrapperPgSQLMixin:
         keys = store_data.keys()
         values = list(store_data.values())
 
-        return sql.SQL(
-            "INSERT INTO {table} ({columns}) VALUES ({values}) RETURNING {id_key}"
-        ).format(
+        return sql.SQL("INSERT INTO {table} ({columns}) VALUES ({values}) RETURNING {id_key}").format(
             table=table_identifier,
             columns=sql.SQL(", ").join(map(sql.Identifier, keys)),
             values=sql.SQL(", ").join(sql.Placeholder() * len(values)),
@@ -152,9 +145,7 @@ class DBWrapperPgSQLMixin:
         update_data: dict[str, Any],
     ) -> sql.Composed:
         keys = update_data.keys()
-        set_clause = sql.SQL(", ").join(
-            sql.Identifier(key) + sql.SQL(" = %s") for key in keys
-        )
+        set_clause = sql.SQL(", ").join(sql.Identifier(key) + sql.SQL(" = %s") for key in keys)
         return sql.SQL("UPDATE {table} SET {set_clause} WHERE {id_key} = %s").format(
             table=table_identifier,
             set_clause=set_clause,

{database_wrapper_pgsql-0.2.14 → database_wrapper_pgsql-0.2.16}/database_wrapper_pgsql/pg_introspector.py

@@ -1,6 +1,7 @@
 import psycopg
 
 from database_wrapper import ColumnMetaIntrospector, DBIntrospector
+
 from .type_mapping import map_db_type
 
 

{database_wrapper_pgsql-0.2.14 → database_wrapper_pgsql-0.2.16}/database_wrapper_pgsql/type_mapping.py

@@ -1,13 +1,14 @@
 # type_mapping_pg.py
-from typing import Any, Optional, Tuple
-from decimal import Decimal
 import datetime
+from decimal import Decimal
+from typing import Any
+
 from database_wrapper import SerializeType
 
 # Flip this if you want lossless decimals
 USE_DECIMAL = False
 
-_PG_TO_PY_BASE: dict[str, Tuple[type, Optional[SerializeType]]] = {
+_PG_TO_PY_BASE: dict[str, tuple[type, SerializeType | None]] = {
     # integers
     "int2": (int, None),
     "int4": (int, None),
@@ -39,7 +40,7 @@ _PG_TO_PY_BASE: dict[str, Tuple[type, Optional[SerializeType]]] = {
 
 def map_db_type(
     db_type: str, *, length: int | None = None, precision: int | None = None, scale: int | None = None
-) -> tuple[type, Optional[SerializeType]]:
+) -> tuple[type, SerializeType | None]:
     t = db_type.lower()
     if t == "numeric":
         if USE_DECIMAL:

{database_wrapper_pgsql-0.2.14 → database_wrapper_pgsql-0.2.16}/database_wrapper_pgsql.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: database_wrapper_pgsql
-Version: 0.2.14
+Version: 0.2.16
 Summary: database_wrapper for PostgreSQL database
 Author-email: Gints Murans <gm@gm.lv>
 License: GNU General Public License v3.0 (GPL-3.0)
@@ -32,7 +32,7 @@ Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: database_wrapper==0.2.14
+Requires-Dist: database_wrapper==0.2.16
 Requires-Dist: psycopg[binary]>=3.2.0
 Requires-Dist: psycopg[pool]>=3.2.0
 

{database_wrapper_pgsql-0.2.14 → database_wrapper_pgsql-0.2.16}/database_wrapper_pgsql.egg-info/requires.txt

@@ -1,3 +1,3 @@
-database_wrapper==0.2.14
+database_wrapper==0.2.16
 psycopg[binary]>=3.2.0
 psycopg[pool]>=3.2.0

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "database_wrapper_pgsql"
-version = "0.2.14"
+version = "0.2.16"
 description = "database_wrapper for PostgreSQL database"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -35,7 +35,7 @@ classifiers = [
 ]
 keywords = ["database", "wrapper", "python", "postgresql", "pgsql"]
 dependencies = [
-    "database_wrapper == 0.2.14",
+    "database_wrapper == 0.2.16",
     "psycopg[binary] >= 3.2.0",
     "psycopg[pool] >= 3.2.0",
 ]

{database_wrapper_pgsql-0.2.14 → database_wrapper_pgsql-0.2.16}/database_wrapper_pgsql/__init__.py

@@ -8,22 +8,22 @@ Part of the database_wrapper package
 
 import logging
 
-from .db_wrapper_pgsql import DBWrapperPgSQL
-from .db_wrapper_pgsql_async import DBWrapperPgSQLAsync
 from .connector import (
     # Basics
     PgConfig,
+    # Connection and Cursor types
+    PgConnectionType,
+    PgConnectionTypeAsync,
+    PgCursorType,
+    PgCursorTypeAsync,
     # Connectors
     PgSQL,
     PgSQLAsync,
     PgSQLWithPooling,
     PgSQLWithPoolingAsync,
-    # Connection and Cursor types
-    PgConnectionType,
-    PgCursorType,
-    PgConnectionTypeAsync,
-    PgCursorTypeAsync,
 )
+from .db_wrapper_pgsql import DBWrapperPgSQL
+from .db_wrapper_pgsql_async import DBWrapperPgSQLAsync
 from .pg_introspector import PostgresIntrospector
 
 # Set the logger to a quiet default, can be enabled if needed