database-wrapper-pgsql 0.1.28__tar.gz → 0.1.33__tar.gz

{database_wrapper_pgsql-0.1.28 → database_wrapper_pgsql-0.1.33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: database_wrapper_pgsql
-Version: 0.1.28
+Version: 0.1.33
 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.1.28
+Requires-Dist: database_wrapper==0.1.33
 Requires-Dist: psycopg[binary]>=3.2.0
 Requires-Dist: psycopg[pool]>=3.2.0
 
@@ -40,7 +40,7 @@ Requires-Dist: psycopg[pool]>=3.2.0
 
 _Part of the `database_wrapper` package._
 
-This python package is a database wrapper for [PostgreSQL](https://www.postgresql.org/) (also called pgsql) databases.
+This python package is a database wrapper for [PostgreSQL](https://www.postgresql.org/) (also called pgsql) database.
 
 ## Installation
 
@@ -51,9 +51,9 @@ pip install database_wrapper[pgsql]
 ## Usage
 
 ```python
-from database_wrapper_pgsql import AsyncPgSQLWithPooling, DBWrapperPgSQL
+from database_wrapper_pgsql import PgSQLWithPoolingAsync, DBWrapperPgSQLAsync
 
-db = MySQL({
+db = PgSQLWithPoolingAsync({
     "hostname": "localhost",
     "port": 3306,
     "username": "root",
@@ -61,7 +61,7 @@ db = MySQL({
     "database": "my_database"
 })
 db.open()
-dbWrapper = DBWrapperMySQL(db=db)
+dbWrapper = DBWrapperPgSQLAsync(db=db)
 
 # Simple query
 aModel = MyModel()
@@ -78,7 +78,7 @@ else:
 # Raw query
 res = await dbWrapper.getAll(
     aModel,
-    """
+    customQuery="""
         SELECT t1.*, t2.name AS other_name
         FROM my_table AS t1
         LEFT JOIN other_table AS t2 ON t1.other_id = t2.id

{database_wrapper_pgsql-0.1.28 → database_wrapper_pgsql-0.1.33}/README.md

@@ -2,7 +2,7 @@
 
 _Part of the `database_wrapper` package._
 
-This python package is a database wrapper for [PostgreSQL](https://www.postgresql.org/) (also called pgsql) databases.
+This python package is a database wrapper for [PostgreSQL](https://www.postgresql.org/) (also called pgsql) database.
 
 ## Installation
 
@@ -13,9 +13,9 @@ pip install database_wrapper[pgsql]
 ## Usage
 
 ```python
-from database_wrapper_pgsql import AsyncPgSQLWithPooling, DBWrapperPgSQL
+from database_wrapper_pgsql import PgSQLWithPoolingAsync, DBWrapperPgSQLAsync
 
-db = MySQL({
+db = PgSQLWithPoolingAsync({
     "hostname": "localhost",
     "port": 3306,
     "username": "root",
@@ -23,7 +23,7 @@ db = MySQL({
     "database": "my_database"
 })
 db.open()
-dbWrapper = DBWrapperMySQL(db=db)
+dbWrapper = DBWrapperPgSQLAsync(db=db)
 
 # Simple query
 aModel = MyModel()
@@ -40,7 +40,7 @@ else:
 # Raw query
 res = await dbWrapper.getAll(
     aModel,
-    """
+    customQuery="""
         SELECT t1.*, t2.name AS other_name
         FROM my_table AS t1
         LEFT JOIN other_table AS t2 ON t1.other_id = t2.id

{database_wrapper_pgsql-0.1.28 → database_wrapper_pgsql-0.1.33}/database_wrapper_pgsql/__init__.py

@@ -9,7 +9,8 @@ Part of the database_wrapper package
 import logging
 
 from .db_wrapper_pgsql import DBWrapperPgSQL
-from .connector import PgConfig, AsyncPgSQLWithPooling, PgSQL
+from .db_wrapper_pgsql_async import DBWrapperPgSQLAsync
+from .connector import PgConfig, PgSQL, PgSQLWithPoolingAsync
 
 # Set the logger to a quiet default, can be enabled if needed
 logger = logging.getLogger("database_wrapper_pgsql")
@@ -18,8 +19,12 @@ if logger.level == logging.NOTSET:
 
 
 __all__ = [
+    # Wrappers
     "DBWrapperPgSQL",
-    "PgConfig",
-    "AsyncPgSQLWithPooling",
+    "DBWrapperPgSQLAsync",
+    # Connectors
     "PgSQL",
+    "PgSQLWithPoolingAsync",
+    # Helpers
+    "PgConfig",
 ]

{database_wrapper_pgsql-0.1.28 → database_wrapper_pgsql-0.1.33}/database_wrapper_pgsql/connector.py

@@ -115,7 +115,7 @@ class PgSQL(DatabaseBackend):
         self.connection.rollback()
 
 
-class AsyncPgSQLWithPooling(DatabaseBackend):
+class PgSQLWithPoolingAsync(DatabaseBackend):
     """
     PostgreSQL database implementation with async and connection pooling
 
@@ -223,7 +223,7 @@ class AsyncPgSQLWithPooling(DatabaseBackend):
                 # Lets do some socket magic
                 self.fixSocketTimeouts(connection.fileno())
 
-                async with timer.aenter("AsyncPgSQLWithPooling.__aenter__.ping"):
+                async with timer.aenter("PgSQLWithPoolingAsync.__aenter__.ping"):
                     async with connection.transaction():
                         await cursor.execute("SELECT 1")
                         await cursor.fetchone()

database_wrapper_pgsql-0.1.33/database_wrapper_pgsql/db_wrapper_pgsql.py

@@ -0,0 +1,498 @@
+import logging
+from typing import Any, Generator, overload
+
+from psycopg import Cursor, sql
+from psycopg.rows import class_row
+
+from database_wrapper import T, OrderByItem, DBWrapper, DBDataModel
+
+from .connector import (
+    # Sync
+    PgConnectionType,
+    PgCursorType,
+    PgSQL,
+)
+
+
+class DBWrapperPgSQL(DBWrapper):
+    """
+    Sync database wrapper for postgres
+    """
+
+    # Override db instance
+    db: PgSQL
+    """ PostgreSQL database connector """
+
+    dbConn: PgConnectionType | None = None
+    """ PostgreSQL connection object """
+
+    #######################
+    ### Class lifecycle ###
+    #######################
+
+    # Meta methods
+    def __init__(
+        self,
+        db: PgSQL,
+        dbConn: PgConnectionType | None = None,
+        logger: logging.Logger | None = None,
+    ):
+        """
+        Initializes a new instance of the DBWrapper class.
+
+        Args:
+            db (MySQL): The PostgreSQL connector.
+            dbConn (MySqlConnection, optional): The PostgreSQL connection object. Defaults to None.
+            logger (logging.Logger, optional): The logger object. Defaults to None.
+        """
+        super().__init__(db, dbConn, logger)
+
+    ######################
+    ### Helper methods ###
+    ######################
+
+    def makeIdentifier(self, schema: str | None, name: str) -> sql.Identifier | str:
+        """
+        Creates a SQL identifier object from the given name.
+
+        Args:
+            name (str): The name to create the identifier from.
+
+        Returns:
+            sql.Identifier: The created SQL identifier object.
+        """
+        if schema:
+            return sql.Identifier(schema, name)
+
+        return sql.Identifier(name)
+
+    @overload
+    def createCursor(self) -> PgCursorType: ...
+
+    @overload
+    def createCursor(
+        self,
+        emptyDataClass: T,
+    ) -> Cursor[T]: ...
+
+    def createCursor(
+        self,
+        emptyDataClass: T | None = None,
+    ) -> Cursor[T] | PgCursorType:
+        """
+        Creates a new cursor object.
+
+        Args:
+            emptyDataClass (DBDataModel | None, optional): The data model to use for the cursor.
+                Defaults to None.
+
+        Returns:
+            PgAsyncCursorType | AsyncCursor[DBDataModel]: The created cursor object.
+        """
+        assert self.db is not None, "Database connection is not set"
+
+        # First we need connection
+        if self.dbConn is None:
+            self.dbConn = self.db.connection
+
+        # Lets make sure we have a connection
+        if self.dbConn is None:
+            raise Exception("Failed to get connection")
+
+        if emptyDataClass is None:
+            return self.dbConn.cursor()
+
+        return self.dbConn.cursor(row_factory=class_row(emptyDataClass.__class__))
+
+    def logQuery(
+        self,
+        cursor: Cursor[Any],
+        query: sql.SQL | sql.Composed,
+        params: tuple[Any, ...],
+    ) -> None:
+        """
+        Logs the given query and parameters.
+
+        Args:
+            cursor (Any): The database cursor.
+            query (Any): The query to log.
+            params (tuple[Any, ...]): The parameters to log.
+        """
+        queryString = query.as_string(self.dbConn)
+        self.logger.debug(f"Query: {queryString}")
+
+    #####################
+    ### Query methods ###
+    #####################
+
+    def filterQuery(
+        self,
+        schemaName: str | None,
+        tableName: str,
+    ) -> sql.SQL | sql.Composed | str:
+        """
+        Creates a SQL query to filter data from the given table.
+
+        Args:
+            schemaName (str): The name of the schema to filter data from.
+            tableName (str): The name of the table to filter data from.
+
+        Returns:
+            sql.SQL | sql.Composed: The created SQL query object.
+        """
+        return sql.SQL("SELECT * FROM {table}").format(
+            table=self.makeIdentifier(schemaName, tableName)
+        )
+
+    def limitQuery(self, offset: int = 0, limit: int = 100) -> sql.Composed | sql.SQL:
+        return sql.SQL("LIMIT {} OFFSET {}").format(limit, offset)
+
+    # Action methods
+    def getOne(
+        self,
+        emptyDataClass: T,
+        customQuery: sql.SQL | sql.Composed | str | None = None,
+    ) -> T | None:
+        """
+        Retrieves a single record from the database.
+
+        Args:
+            emptyDataClass (T): The data model to use for the query.
+            customQuery (sql.SQL | sql.Composed | str | None, optional): The custom query to use.
+                Defaults to None.
+
+        Returns:
+            T | None: The result of the query.
+        """
+        # Query
+        _query = (
+            customQuery
+            or emptyDataClass.queryBase()
+            or self.filterQuery(emptyDataClass.schemaName, emptyDataClass.tableName)
+        )
+        idKey = emptyDataClass.idKey
+        idValue = emptyDataClass.id
+        if not idKey:
+            raise ValueError("Id key is not set")
+        if not idValue:
+            raise ValueError("Id value is not set")
+
+        # Create a SQL object for the query and format it
+        querySql = sql.SQL("{query} WHERE {idkey} = %s").format(
+            query=_query, idkey=self.makeIdentifier(emptyDataClass.tableAlias, idKey)
+        )
+
+        # Create a new cursor
+        newCursor = self.createCursor(emptyDataClass)
+
+        # Log
+        self.logQuery(newCursor, querySql, (idValue,))
+
+        # Load data
+        try:
+
+            newCursor.execute(querySql, (idValue,))
+            dbData = newCursor.fetchone()
+
+            return dbData
+
+        finally:
+            # Close the cursor
+            newCursor.close()
+
+    def getByKey(
+        self,
+        emptyDataClass: T,
+        idKey: str,
+        idValue: Any,
+        customQuery: sql.SQL | sql.Composed | str | None = None,
+    ) -> T | None:
+        """
+        Retrieves a single record from the database using the given key.
+
+        Args:
+            emptyDataClass (T): The data model to use for the query.
+            idKey (str): The name of the key to use for the query.
+            idValue (Any): The value of the key to use for the query.
+            customQuery (sql.SQL | sql.Composed | str | None, optional): The custom query to use.
+                Defaults to None.
+
+        Returns:
+            T | None: The result of the query.
+        """
+        # Query
+        _query = (
+            customQuery
+            or emptyDataClass.queryBase()
+            or self.filterQuery(emptyDataClass.schemaName, emptyDataClass.tableName)
+        )
+
+        # Create a SQL object for the query and format it
+        querySql = sql.SQL("{} WHERE {} = %s").format(
+            _query, self.makeIdentifier(emptyDataClass.tableAlias, idKey)
+        )
+
+        # Create a new cursor
+        newCursor = self.createCursor(emptyDataClass)
+
+        # Log
+        self.logQuery(newCursor, querySql, (idValue,))
+
+        # Load data
+        try:
+            newCursor.execute(querySql, (idValue,))
+            dbData = newCursor.fetchone()
+
+            return dbData
+
+        finally:
+            # Ensure the cursor is closed after the generator is exhausted or an error occurs
+            newCursor.close()
+
+    def getAll(
+        self,
+        emptyDataClass: T,
+        idKey: str | None = None,
+        idValue: Any | None = None,
+        orderBy: OrderByItem | None = None,
+        offset: int = 0,
+        limit: int = 100,
+        customQuery: sql.SQL | sql.Composed | str | None = None,
+    ) -> Generator[T, None, None]:
+        """
+        Retrieves all records from the database.
+
+        Args:
+            emptyDataClass (T): The data model to use for the query.
+            idKey (str | None, optional): The name of the key to use for filtering. Defaults to None.
+            idValue (Any | None, optional): The value of the key to use for filtering. Defaults to None.
+            orderBy (OrderByItem | None, optional): The order by item to use for sorting. Defaults to None.
+            offset (int, optional): The number of results to skip. Defaults to 0.
+            limit (int, optional): The maximum number of results to return. Defaults to 100.
+            customQuery (sql.SQL | sql.Composed | str | None, optional): The custom query to use. Defaults to None.
+
+        Returns:
+            Generator[T, None, None]: The result of the query.
+        """
+        # Query
+        _query = (
+            customQuery
+            or emptyDataClass.queryBase()
+            or self.filterQuery(emptyDataClass.schemaName, emptyDataClass.tableName)
+        )
+        _params: tuple[Any, ...] = ()
+
+        # Filter
+        if idKey and idValue:
+            _query = sql.SQL("{} WHERE {} = %s").format(
+                _query, self.makeIdentifier(emptyDataClass.tableAlias, idKey)
+            )
+            _params = (idValue,)
+
+        # Limits
+        _order: sql.Composable = sql.SQL("")
+        _limit: sql.Composable = sql.SQL("")
+
+        if orderBy:
+            orderList = [
+                f"{item[0]} {item[1] if len(item) > 1 and item[1] != None else 'ASC'}"
+                for item in orderBy
+            ]
+            _order = sql.SQL("ORDER BY %s" % ", ".join(orderList))  # type: ignore
+        if offset or limit:
+            _limit = sql.SQL("{}").format(self.limitQuery(offset, limit))
+
+        # Create a SQL object for the query and format it
+        querySql = sql.SQL("{query} {order} {limit}").format(
+            query=_query, order=_order, limit=_limit
+        )
+
+        # Create a new cursor
+        newCursor = self.createCursor(emptyDataClass)
+
+        # Log
+        self.logQuery(newCursor, querySql, _params)
+
+        # Load data
+        try:
+            newCursor.execute(querySql, _params)
+            while True:
+                row = newCursor.fetchone()
+                if row is None:
+                    break
+                yield row
+
+        finally:
+            # Close the cursor
+            newCursor.close()
+
+    def getFiltered(
+        self,
+        emptyDataClass: T,
+        filter: dict[str, Any],
+        orderBy: OrderByItem | None = None,
+        offset: int = 0,
+        limit: int = 100,
+        customQuery: sql.SQL | sql.Composed | str | None = None,
+    ) -> Generator[T, None, None]:
+        # Filter
+        _query = (
+            customQuery
+            or emptyDataClass.queryBase()
+            or self.filterQuery(emptyDataClass.schemaName, emptyDataClass.tableName)
+        )
+        (_filter, _params) = self.createFilter(filter)
+        _filter = sql.SQL(_filter)  # type: ignore
+
+        # Limits
+        _order: sql.Composable = sql.SQL("")
+        _limit: sql.Composable = sql.SQL("")
+
+        if orderBy:
+            orderList = [
+                f"{item[0]} {item[1] if len(item) > 1 and item[1] != None else 'ASC'}"
+                for item in orderBy
+            ]
+            _order = sql.SQL("ORDER BY %s" % ", ".join(orderList))  # type: ignore
+        if offset or limit:
+            _limit = sql.SQL("{}").format(self.limitQuery(offset, limit))
+
+        # Create a SQL object for the query and format it
+        querySql = sql.SQL("{query} {filter} {order} {limit}").format(
+            query=_query, filter=_filter, order=_order, limit=_limit
+        )
+
+        # Create a new cursor
+        newCursor = self.createCursor(emptyDataClass)
+
+        # Log
+        self.logQuery(newCursor, querySql, _params)
+
+        # Load data
+        try:
+            newCursor.execute(querySql, _params)
+            while True:
+                row = newCursor.fetchone()
+                if row is None:
+                    break
+                yield row
+
+        finally:
+            # Close the cursor
+            newCursor.close()
+
+    def _store(
+        self,
+        emptyDataClass: DBDataModel,
+        schemaName: str | None,
+        tableName: str,
+        storeData: dict[str, Any],
+        idKey: str,
+    ) -> tuple[int, int]:
+        keys = storeData.keys()
+        values = list(storeData.values())
+
+        tableIdentifier = self.makeIdentifier(schemaName, tableName)
+        returnKey = self.makeIdentifier(emptyDataClass.tableAlias, idKey)
+
+        insertQuery = sql.SQL(
+            "INSERT INTO {table} ({columns}) VALUES ({values}) RETURNING {id_key}"
+        ).format(
+            table=tableIdentifier,
+            columns=sql.SQL(", ").join(map(sql.Identifier, keys)),
+            values=sql.SQL(", ").join(sql.Placeholder() * len(values)),
+            id_key=returnKey,
+        )
+
+        # Create a new cursor
+        newCursor = self.createCursor(emptyDataClass)
+
+        # Log
+        self.logQuery(newCursor, insertQuery, tuple(values))
+
+        # Insert
+        try:
+            newCursor.execute(insertQuery, tuple(values))
+            affectedRows = newCursor.rowcount
+            result = newCursor.fetchone()
+
+            return (
+                result.id if result and hasattr(result, "id") else 0,
+                affectedRows,
+            )
+
+        finally:
+            # Close the cursor
+            newCursor.close()
+
+    def _update(
+        self,
+        emptyDataClass: DBDataModel,
+        schemaName: str | None,
+        tableName: str,
+        updateData: dict[str, Any],
+        updateId: tuple[str, Any],
+    ) -> int:
+        (idKey, idValue) = updateId
+        keys = updateData.keys()
+        values = list(updateData.values())
+        values.append(idValue)
+
+        set_clause = sql.SQL(", ").join(
+            sql.Identifier(key) + sql.SQL(" = %s") for key in keys
+        )
+
+        tableIdentifier = self.makeIdentifier(schemaName, tableName)
+        updateKey = self.makeIdentifier(emptyDataClass.tableAlias, idKey)
+        updateQuery = sql.SQL(
+            "UPDATE {table} SET {set_clause} WHERE {id_key} = %s"
+        ).format(
+            table=tableIdentifier,
+            set_clause=set_clause,
+            id_key=updateKey,
+        )
+
+        # Create a new cursor
+        newCursor = self.createCursor(emptyDataClass)
+
+        # Log
+        self.logQuery(newCursor, updateQuery, tuple(values))
+
+        # Update
+        try:
+            newCursor.execute(updateQuery, tuple(values))
+            affectedRows = newCursor.rowcount
+
+            return affectedRows
+
+        finally:
+            # Close the cursor
+            newCursor.close()
+
+    def _delete(
+        self,
+        emptyDataClass: DBDataModel,
+        schemaName: str | None,
+        tableName: str,
+        deleteId: tuple[str, Any],
+    ) -> int:
+        (idKey, idValue) = deleteId
+
+        tableIdentifier = self.makeIdentifier(schemaName, tableName)
+        deleteKey = self.makeIdentifier(emptyDataClass.tableAlias, idKey)
+
+        delete_query = sql.SQL("DELETE FROM {table} WHERE {id_key} = %s").format(
+            table=tableIdentifier, id_key=deleteKey
+        )
+
+        # Create a new cursor
+        newCursor = self.createCursor(emptyDataClass)
+
+        # Log
+        self.logQuery(newCursor, delete_query, (idValue,))
+
+        # Delete
+        newCursor.execute(delete_query, (idValue,))
+        affected_rows = newCursor.rowcount
+
+        return affected_rows

database_wrapper_pgsql-0.1.28/database_wrapper_pgsql/db_wrapper_pgsql.py → database_wrapper_pgsql-0.1.33/database_wrapper_pgsql/db_wrapper_pgsql_async.py

@@ -1,34 +1,33 @@
 import logging
 from typing import Any, AsyncGenerator, overload
 
-from psycopg import Cursor, AsyncCursor, sql
+from psycopg import AsyncCursor, sql
 from psycopg.rows import class_row
 
-from database_wrapper import T, OrderByItem, DBWrapper, DBDataModel
+from database_wrapper import T, OrderByItem, DBWrapperAsync, DBDataModel
 
 from .connector import (
-    # Sync
-    PgConnectionType,
-    PgCursorType,
-    PgSQL,
     # Async
     PgAsyncConnectionType,
     PgAsyncCursorType,
-    AsyncPgSQLWithPooling,
+    PgSQLWithPoolingAsync,
 )
 
 
-class DBWrapperPgSQL(DBWrapper):
+class DBWrapperPgSQLAsync(DBWrapperAsync):
     """
-    Database wrapper for postgres
-
-    This is meant to be used in async environments. Also remember to call close() when done.
+    Async database wrapper for postgres
 
+    This is meant to be used in async environments.
+    Also remember to call close() when done as we cannot do that in __del__.
     """
 
     # Override db instance
-    db: PgSQL | AsyncPgSQLWithPooling
-    dbConn: PgConnectionType | PgAsyncConnectionType | None = None
+    db: PgSQLWithPoolingAsync
+    """ Async PostgreSQL database connector """
+
+    dbConn: PgAsyncConnectionType | None = None
+    """ Async PostgreSQL connection object """
 
     #######################
     ### Class lifecycle ###
@@ -37,24 +36,25 @@ class DBWrapperPgSQL(DBWrapper):
     # Meta methods
     def __init__(
         self,
-        db: PgSQL | AsyncPgSQLWithPooling,
-        dbConn: PgConnectionType | PgAsyncConnectionType | None = None,
+        db: PgSQLWithPoolingAsync,
+        dbConn: PgAsyncConnectionType | None = None,
         logger: logging.Logger | None = None,
     ):
         """
         Initializes a new instance of the DBWrapper class.
 
         Args:
-            db (MySQL): The MySQL object.
+            db (MySQL): The PostgreSQL database connector.
+            dbConn (MySqlConnection, optional): The PostgreSQL connection object. Defaults to None.
             logger (logging.Logger, optional): The logger object. Defaults to None.
         """
         super().__init__(db, dbConn, logger)
 
     async def close(self) -> None:
         if hasattr(self, "dbConn") and self.dbConn and hasattr(self, "db") and self.db:
-            if isinstance(self.db, AsyncPgSQLWithPooling):
-                await self.db.returnConnection(self.dbConn)  # type: ignore
-            self.dbConn = None
+            await self.db.returnConnection(self.dbConn)
+
+        await super().close()
 
     ######################
     ### Helper methods ###
@@ -76,18 +76,18 @@ class DBWrapperPgSQL(DBWrapper):
         return sql.Identifier(name)
 
     @overload
-    async def createCursor(self) -> PgCursorType | PgAsyncCursorType: ...
+    async def createCursor(self) -> PgAsyncCursorType: ...
 
     @overload
     async def createCursor(
         self,
         emptyDataClass: T,
-    ) -> Cursor[T] | AsyncCursor[T]: ...
+    ) -> AsyncCursor[T]: ...
 
     async def createCursor(
         self,
         emptyDataClass: T | None = None,
-    ) -> Cursor[T] | PgCursorType | AsyncCursor[T] | PgAsyncCursorType:
+    ) -> AsyncCursor[T] | PgAsyncCursorType:
         """
         Creates a new cursor object.
 
@@ -102,20 +102,12 @@ class DBWrapperPgSQL(DBWrapper):
 
         # First we need connection
         if self.dbConn is None:
-            if isinstance(self.db, PgSQL):
-                self.dbConn = self.db.connection
-
-            if isinstance(self.db, AsyncPgSQLWithPooling):
-                status = await self.db.newConnection()
-                if not status:
-                    raise Exception("Failed to create new connection")
+            status = await self.db.newConnection()
+            if not status:
+                raise Exception("Failed to create new connection")
 
-                (pgConn, _pgCur) = status
-                self.dbConn = pgConn
-
-        # Lets make sure we have a connection
-        if self.dbConn is None:
-            raise Exception("Failed to get connection")
+            (pgConn, _pgCur) = status
+            self.dbConn = pgConn
 
         if emptyDataClass is None:
             return self.dbConn.cursor()
@@ -124,7 +116,7 @@ class DBWrapperPgSQL(DBWrapper):
 
     def logQuery(
         self,
-        cursor: AsyncCursor[Any] | Cursor[Any],
+        cursor: AsyncCursor[Any],
         query: sql.SQL | sql.Composed,
         params: tuple[Any, ...],
     ) -> None:
@@ -208,21 +200,14 @@ class DBWrapperPgSQL(DBWrapper):
 
         # Load data
         try:
-            if isinstance(newCursor, AsyncCursor):
-                await newCursor.execute(querySql, (idValue,))
-                dbData = await newCursor.fetchone()
-            else:
-                newCursor.execute(querySql, (idValue,))
-                dbData = newCursor.fetchone()
+            await newCursor.execute(querySql, (idValue,))
+            dbData = await newCursor.fetchone()
 
             return dbData
 
         finally:
             # Close the cursor
-            if isinstance(newCursor, AsyncCursor):
-                await newCursor.close()
-            else:
-                newCursor.close()
+            await newCursor.close()
 
     async def getByKey(
         self,
@@ -264,21 +249,14 @@ class DBWrapperPgSQL(DBWrapper):
 
         # Load data
         try:
-            if isinstance(newCursor, AsyncCursor):
-                await newCursor.execute(querySql, (idValue,))
-                dbData = await newCursor.fetchone()
-            else:
-                newCursor.execute(querySql, (idValue,))
-                dbData = newCursor.fetchone()
+            await newCursor.execute(querySql, (idValue,))
+            dbData = await newCursor.fetchone()
 
             return dbData
 
         finally:
             # Ensure the cursor is closed after the generator is exhausted or an error occurs
-            if isinstance(newCursor, AsyncCursor):
-                await newCursor.close()
-            else:
-                newCursor.close()
+            await newCursor.close()
 
     async def getAll(
         self,
@@ -346,29 +324,19 @@ class DBWrapperPgSQL(DBWrapper):
 
         # Load data
         try:
-            if isinstance(newCursor, AsyncCursor):
-                # Execute the query
-                await newCursor.execute(querySql, _params)
-
-                # Instead of fetchall(), we'll use a generator to yield results one by one
-                while True:
-                    row = await newCursor.fetchone()
-                    if row is None:
-                        break
-                    yield row
-            else:
-                newCursor.execute(querySql, _params)
-                while True:
-                    row = newCursor.fetchone()
-                    if row is None:
-                        break
-                    yield row
+            # Execute the query
+            await newCursor.execute(querySql, _params)
+
+            # Instead of fetchall(), we'll use a generator to yield results one by one
+            while True:
+                row = await newCursor.fetchone()
+                if row is None:
+                    break
+                yield row
+
         finally:
             # Ensure the cursor is closed after the generator is exhausted or an error occurs
-            if isinstance(newCursor, AsyncCursor):
-                await newCursor.close()
-            else:
-                newCursor.close()
+            await newCursor.close()
 
     async def getFiltered(
         self,
@@ -414,29 +382,19 @@ class DBWrapperPgSQL(DBWrapper):
 
         # Load data
         try:
-            if isinstance(newCursor, AsyncCursor):
-                # Execute the query
-                await newCursor.execute(querySql, _params)
-
-                # Instead of fetchall(), we'll use a generator to yield results one by one
-                while True:
-                    row = await newCursor.fetchone()
-                    if row is None:
-                        break
-                    yield row
-            else:
-                newCursor.execute(querySql, _params)
-                while True:
-                    row = newCursor.fetchone()
-                    if row is None:
-                        break
-                    yield row
+            # Execute the query
+            await newCursor.execute(querySql, _params)
+
+            # Instead of fetchall(), we'll use a generator to yield results one by one
+            while True:
+                row = await newCursor.fetchone()
+                if row is None:
+                    break
+                yield row
+
         finally:
-            # Ensure the cursor is closed after the generator is exhausted or an error occurs
-            if isinstance(newCursor, AsyncCursor):
-                await newCursor.close()
-            else:
-                newCursor.close()
+            # Close the cursor
+            await newCursor.close()
 
     async def _store(
         self,
@@ -468,19 +426,19 @@ class DBWrapperPgSQL(DBWrapper):
         self.logQuery(newCursor, insertQuery, tuple(values))
 
         # Insert
-        if isinstance(newCursor, AsyncCursor):
+        try:
             await newCursor.execute(insertQuery, tuple(values))
             affectedRows = newCursor.rowcount
             result = await newCursor.fetchone()
-        else:
-            newCursor.execute(insertQuery, tuple(values))
-            affectedRows = newCursor.rowcount
-            result = newCursor.fetchone()
 
-        return (
-            result.id if result and hasattr(result, "id") else 0,
-            affectedRows,
-        )
+            return (
+                result.id if result and hasattr(result, "id") else 0,
+                affectedRows,
+            )
+
+        finally:
+            # Close the cursor
+            await newCursor.close()
 
     async def _update(
         self,
@@ -516,13 +474,15 @@ class DBWrapperPgSQL(DBWrapper):
         self.logQuery(newCursor, updateQuery, tuple(values))
 
         # Update
-        if isinstance(newCursor, AsyncCursor):
+        try:
             await newCursor.execute(updateQuery, tuple(values))
-        else:
-            newCursor.execute(updateQuery, tuple(values))
-        affectedRows = newCursor.rowcount
+            affectedRows = newCursor.rowcount
 
-        return affectedRows
+            return affectedRows
+
+        finally:
+            # Close the cursor
+            await newCursor.close()
 
     async def _delete(
         self,
@@ -547,10 +507,12 @@ class DBWrapperPgSQL(DBWrapper):
         self.logQuery(newCursor, delete_query, (idValue,))
 
         # Delete
-        if isinstance(newCursor, AsyncCursor):
+        try:
             await newCursor.execute(delete_query, (idValue,))
-        else:
-            newCursor.execute(delete_query, (idValue,))
-        affected_rows = newCursor.rowcount
+            affected_rows = newCursor.rowcount
 
-        return affected_rows
+            return affected_rows
+
+        finally:
+            # Close the cursor
+            await newCursor.close()

{database_wrapper_pgsql-0.1.28 → database_wrapper_pgsql-0.1.33}/database_wrapper_pgsql.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: database_wrapper_pgsql
-Version: 0.1.28
+Version: 0.1.33
 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.1.28
+Requires-Dist: database_wrapper==0.1.33
 Requires-Dist: psycopg[binary]>=3.2.0
 Requires-Dist: psycopg[pool]>=3.2.0
 
@@ -40,7 +40,7 @@ Requires-Dist: psycopg[pool]>=3.2.0
 
 _Part of the `database_wrapper` package._
 
-This python package is a database wrapper for [PostgreSQL](https://www.postgresql.org/) (also called pgsql) databases.
+This python package is a database wrapper for [PostgreSQL](https://www.postgresql.org/) (also called pgsql) database.
 
 ## Installation
 
@@ -51,9 +51,9 @@ pip install database_wrapper[pgsql]
 ## Usage
 
 ```python
-from database_wrapper_pgsql import AsyncPgSQLWithPooling, DBWrapperPgSQL
+from database_wrapper_pgsql import PgSQLWithPoolingAsync, DBWrapperPgSQLAsync
 
-db = MySQL({
+db = PgSQLWithPoolingAsync({
     "hostname": "localhost",
     "port": 3306,
     "username": "root",
@@ -61,7 +61,7 @@ db = MySQL({
     "database": "my_database"
 })
 db.open()
-dbWrapper = DBWrapperMySQL(db=db)
+dbWrapper = DBWrapperPgSQLAsync(db=db)
 
 # Simple query
 aModel = MyModel()
@@ -78,7 +78,7 @@ else:
 # Raw query
 res = await dbWrapper.getAll(
     aModel,
-    """
+    customQuery="""
         SELECT t1.*, t2.name AS other_name
         FROM my_table AS t1
         LEFT JOIN other_table AS t2 ON t1.other_id = t2.id

{database_wrapper_pgsql-0.1.28 → database_wrapper_pgsql-0.1.33}/database_wrapper_pgsql.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ pyproject.toml
 database_wrapper_pgsql/__init__.py
 database_wrapper_pgsql/connector.py
 database_wrapper_pgsql/db_wrapper_pgsql.py
+database_wrapper_pgsql/db_wrapper_pgsql_async.py
 database_wrapper_pgsql/py.typed
 database_wrapper_pgsql.egg-info/PKG-INFO
 database_wrapper_pgsql.egg-info/SOURCES.txt

{database_wrapper_pgsql-0.1.28 → database_wrapper_pgsql-0.1.33}/database_wrapper_pgsql.egg-info/requires.txt

@@ -1,3 +1,3 @@
-database_wrapper==0.1.28
+database_wrapper==0.1.33
 psycopg[binary]>=3.2.0
 psycopg[pool]>=3.2.0

{database_wrapper_pgsql-0.1.28 → database_wrapper_pgsql-0.1.33}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "database_wrapper_pgsql"
-version = "0.1.28"
+version = "0.1.33"
 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.1.28",
+    "database_wrapper == 0.1.33",
     "psycopg[binary] >= 3.2.0",
     "psycopg[pool] >= 3.2.0",
 ]