database-wrapper-pgsql 0.1.85__py3-none-any.whl → 0.2.2__py3-none-any.whl

database_wrapper_pgsql/connector.py

@@ -96,7 +96,7 @@ class PgSQL(DatabaseBackend):
                 user=self.config["username"],
                 password=self.config["password"],
                 dbname=self.config["database"],
-                connect_timeout=self.connectionTimeout,
+                connect_timeout=self.connection_timeout,
                 row_factory=PgDictRowFactory,  # type: ignore
                 **self.config["kwargs"],
             ),
@@ -104,7 +104,7 @@ class PgSQL(DatabaseBackend):
         self.cursor = self.connection.cursor(row_factory=PgDictRowFactory)
 
         # Lets do some socket magic
-        self.fixSocketTimeouts(self.connection.fileno())
+        self.fix_socket_timeouts(self.connection.fileno())
 
     def ping(self) -> bool:
         try:
@@ -123,11 +123,11 @@ class PgSQL(DatabaseBackend):
     @contextmanager
     def transaction(
         self,
-        dbConn: PgConnectionType | None = None,
+        db_conn: PgConnectionType | None = None,
     ) -> Iterator[Transaction]:
         """Transaction context manager"""
-        if dbConn:
-            with dbConn.transaction() as trans:
+        if db_conn:
+            with db_conn.transaction() as trans:
                 yield trans
 
         assert self.connection, "Connection is not initialized"
@@ -138,7 +138,7 @@ class PgSQL(DatabaseBackend):
     ### Data ###
     ############
 
-    def affectedRows(self) -> int:
+    def affected_rows(self) -> int:
         assert self.cursor, "Cursor is not initialized"
 
         return self.cursor.rowcount
@@ -215,14 +215,14 @@ class PgSQLAsync(DatabaseBackend):
             user=self.config["username"],
             password=self.config["password"],
             dbname=self.config["database"],
-            connect_timeout=self.connectionTimeout,
+            connect_timeout=self.connection_timeout,
             row_factory=PgDictRowFactory,  # type: ignore
             **self.config["kwargs"],
         )
         self.cursor = self.connection.cursor(row_factory=PgDictRowFactory)
 
         # Lets do some socket magic
-        self.fixSocketTimeouts(self.connection.fileno())
+        self.fix_socket_timeouts(self.connection.fileno())
 
     async def close(self) -> Any:
         """Close connections"""
@@ -251,11 +251,11 @@ class PgSQLAsync(DatabaseBackend):
     @asynccontextmanager
     async def transaction(
         self,
-        dbConn: PgConnectionTypeAsync | None = None,
+        db_conn: PgConnectionTypeAsync | None = None,
     ) -> AsyncIterator[AsyncTransaction]:
         """Transaction context manager"""
-        if dbConn:
-            async with dbConn.transaction() as trans:
+        if db_conn:
+            async with db_conn.transaction() as trans:
                 yield trans
 
         assert self.connection, "Connection is not initialized"
@@ -266,7 +266,7 @@ class PgSQLAsync(DatabaseBackend):
     ### Data ###
     ############
 
-    def affectedRows(self) -> int:
+    def affected_rows(self) -> int:
         assert self.cursor, "Cursor is not initialized"
 
         return self.cursor.rowcount
@@ -291,24 +291,24 @@ class PgSQLWithPooling(DatabaseBackend):
     PostgreSQL database implementation with connection pooling.
 
     Instance is created without actually connecting to the database.
-    When you are ready to connect, call openPool() method.
+    When you are ready to connect, call open_pool() method.
 
-    Then you can use newConnection() to get connection from the pool and
-    returnConnection() to return it back.
+    Then you can use new_connection() to get connection from the pool and
+    return_connection() to return it back.
     Or use context manager to get connection and return it back automatically,
     for example:
 
         pool = PgSQLWithPooling(config)
-        pool.openPool()
+        pool.open_pool()
         with pool as (connection, cursor):
             cursor.execute("SELECT 1")
 
     :param config: Configuration for PostgreSQL
     :type config: PgConfig
-    :param connectionTimeout: Connection timeout
-    :type connectionTimeout: int
-    :param instanceName: Name of the instance
-    :type instanceName: str
+    :param connection_timeout: Connection timeout
+    :type connection_timeout: int
+    :param instance_name: Name of the instance
+    :type instance_name: str
 
     Defaults:
         port = 5432
@@ -328,7 +328,7 @@ class PgSQLWithPooling(DatabaseBackend):
     cursor: PgCursorType | None
     """ Cursor to database """
 
-    contextConnection: ContextVar[tuple[PgConnectionType, PgCursorType] | None]
+    context_connection: ContextVar[tuple[PgConnectionType, PgCursorType] | None]
     """ Connection used in context manager """
 
     ########################
@@ -337,19 +337,19 @@ class PgSQLWithPooling(DatabaseBackend):
 
     def __init__(
         self,
-        dbConfig: PgConfig,
-        connectionTimeout: int = 5,
-        instanceName: str = "postgresql_pool",
+        db_config: PgConfig,
+        connection_timeout: int = 5,
+        instance_name: str = "postgresql_pool",
     ) -> None:
         """
         Main concept here is that in init we do not connect to database,
         so that class instances can be safely made regardless of connection statuss.
 
-        Remember to call openPool() after creating instance to actually open the pool to the database
-        and also closePool() to close the pool.
+        Remember to call open_pool() after creating instance to actually open the pool to the database
+        and also close_pool() to close the pool.
         """
 
-        super().__init__(dbConfig, connectionTimeout, instanceName)
+        super().__init__(db_config, connection_timeout, instance_name)
 
         # Set defaults
         if not "port" in self.config or not self.config["port"]:
@@ -371,19 +371,19 @@ class PgSQLWithPooling(DatabaseBackend):
         if not "pool_kwargs" in self.config or not self.config["pool_kwargs"]:
             self.config["pool_kwargs"] = {}
 
-        connStr = (
+        conn_str = (
             f"postgresql://{self.config['username']}:{self.config['password']}@{self.config['hostname']}:{self.config['port']}"
-            f"/{self.config['database']}?connect_timeout={self.connectionTimeout}&application_name={self.name}"
+            f"/{self.config['database']}?connect_timeout={self.connection_timeout}&application_name={self.name}"
             f"&sslmode={self.config['ssl']}"
         )
         self.pool = ConnectionPool(
-            connStr,
+            conn_str,
             open=False,
             min_size=2,
             max_size=self.config["maxconnections"],
             max_lifetime=20 * 60,
             max_idle=400,
-            timeout=self.connectionTimeout,
+            timeout=self.connection_timeout,
             reconnect_timeout=0,
             num_workers=4,
             connection_class=PgConnectionType,
@@ -395,15 +395,15 @@ class PgSQLWithPooling(DatabaseBackend):
     ### Connection ###
     ##################
 
-    def openPool(self) -> None:
-        self.pool.open(wait=True, timeout=self.connectionTimeout)
+    def open_pool(self) -> None:
+        self.pool.open(wait=True, timeout=self.connection_timeout)
 
-    def closePool(self) -> None:
+    def close_pool(self) -> None:
         """Close Pool"""
 
-        if self.shutdownRequested.is_set():
+        if self.shutdown_requested.is_set():
             return
-        self.shutdownRequested.set()
+        self.shutdown_requested.set()
 
         # Close pool
         self.logger.debug("Closing connection pool")
@@ -417,11 +417,11 @@ class PgSQLWithPooling(DatabaseBackend):
             self.close()
 
         # Create new connection
-        res = self.newConnection()
+        res = self.new_connection()
         if res:
             (self.connection, self.cursor) = res
 
-    def newConnection(
+    def new_connection(
         self,
     ) -> tuple[PgConnectionType, PgCursorType] | None:
         assert self.pool, "Pool is not initialized"
@@ -431,14 +431,14 @@ class PgSQLWithPooling(DatabaseBackend):
 
         # Get connection from the pool
         tries = 0
-        while not self.shutdownRequested.is_set():
+        while not self.shutdown_requested.is_set():
             connection = None
             try:
-                connection = self.pool.getconn(timeout=self.connectionTimeout)
+                connection = self.pool.getconn(timeout=self.connection_timeout)
                 cursor = connection.cursor(row_factory=PgDictRowFactory)
 
                 # Lets do some socket magic
-                self.fixSocketTimeouts(connection.fileno())
+                self.fix_socket_timeouts(connection.fileno())
 
                 with connection.transaction():
                     cursor.execute("SELECT 1")
@@ -452,7 +452,7 @@ class PgSQLWithPooling(DatabaseBackend):
                     self.pool.putconn(connection)
 
                 self.logger.error(f"Error while getting connection from the pool: {e}")
-                self.shutdownRequested.wait(self.slowDownTimeout)
+                self.shutdown_requested.wait(self.slow_down_timeout)
                 tries += 1
                 if tries >= 3:
                     break
@@ -460,7 +460,7 @@ class PgSQLWithPooling(DatabaseBackend):
 
         return None
 
-    def returnConnection(self, connection: PgConnectionType) -> None:
+    def return_connection(self, connection: PgConnectionType) -> None:
         """Return connection to the pool"""
         assert self.pool, "Pool is not initialized"
 
@@ -483,11 +483,11 @@ class PgSQLWithPooling(DatabaseBackend):
         """Context manager"""
 
         # Lets set the context var so that it is set even if we fail to get connection
-        self.contextConnection.set(None)
+        self.context_connection.set(None)
 
-        res = self.newConnection()
+        res = self.new_connection()
         if res:
-            self.contextConnection.set(res)
+            self.context_connection.set(res)
             return res
 
         return (
@@ -498,12 +498,12 @@ class PgSQLWithPooling(DatabaseBackend):
     def __exit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
         """Context manager"""
 
-        testData = self.contextConnection.get()
-        if testData:
-            self.returnConnection(testData[0])
+        test_data = self.context_connection.get()
+        if test_data:
+            self.return_connection(test_data[0])
 
         # Reset context
-        self.contextConnection.set(None)
+        self.context_connection.set(None)
 
     ####################
     ### Transactions ###
@@ -512,11 +512,11 @@ class PgSQLWithPooling(DatabaseBackend):
     @contextmanager
     def transaction(
         self,
-        dbConn: PgConnectionType | None = None,
+        db_conn: PgConnectionType | None = None,
     ) -> Iterator[Transaction]:
         """Transaction context manager"""
-        if dbConn:
-            with dbConn.transaction() as trans:
+        if db_conn:
+            with db_conn.transaction() as trans:
                 yield trans
 
         assert self.connection, "Connection is not initialized"
@@ -527,7 +527,7 @@ class PgSQLWithPooling(DatabaseBackend):
     ### Data ###
     ############
 
-    def affectedRows(self) -> int:
+    def affected_rows(self) -> int:
         assert self.cursor, "Cursor is not initialized"
 
         return self.cursor.rowcount
@@ -552,29 +552,29 @@ class PgSQLWithPoolingAsync(DatabaseBackend):
     PostgreSQL database implementation with async connection pooling.
 
     Instance is created without actually connecting to the database.
-    When you are ready to connect, call await openPool() method.
+    When you are ready to connect, call await open_pool() method.
 
-    Then you can use newConnection() to get connection from the pool and
-    returnConnection() to return it back.
+    Then you can use new_connection() to get connection from the pool and
+    return_connection() to return it back.
 
     Or use context manager to get connection and return it back automatically,
     for example:
 
         pool = PgSQLWithPoolingAsync(config)
-        await pool.openPool()
+        await pool.open_pool()
         async with pool as (connection, cursor):
             await cursor.execute("SELECT 1")
 
 
     ! Note: Close is not called automatically when class is destroyed.
-    ! You need to call `await closePool()` manually in async environment.
+    ! You need to call `await close_pool()` manually in async environment.
 
     :param config: Configuration for PostgreSQL
     :type config: PgConfig
-    :param connectionTimeout: Connection timeout
-    :type connectionTimeout: int
-    :param instanceName: Name of the instance
-    :type instanceName: str
+    :param connection_timeout: Connection timeout
+    :type connection_timeout: int
+    :param instance_name: Name of the instance
+    :type instance_name: str
 
     Defaults:
         port = 5432
@@ -585,7 +585,7 @@ class PgSQLWithPoolingAsync(DatabaseBackend):
     config: PgConfig
     """ Configuration """
 
-    poolAsync: AsyncConnectionPool[PgConnectionTypeAsync]
+    pool_async: AsyncConnectionPool[PgConnectionTypeAsync]
     """ Connection pool """
 
     connection: PgConnectionTypeAsync | None
@@ -594,7 +594,7 @@ class PgSQLWithPoolingAsync(DatabaseBackend):
     cursor: PgCursorTypeAsync | None
     """ Cursor to database """
 
-    contextConnectionAsync: ContextVar[
+    context_connection_async: ContextVar[
         tuple[PgConnectionTypeAsync, PgCursorTypeAsync] | None
     ]
     """ Connection used in async context manager """
@@ -605,19 +605,19 @@ class PgSQLWithPoolingAsync(DatabaseBackend):
 
     def __init__(
         self,
-        dbConfig: PgConfig,
-        connectionTimeout: int = 5,
-        instanceName: str = "async_postgresql",
+        db_config: PgConfig,
+        connection_timeout: int = 5,
+        instance_name: str = "async_postgresql",
     ) -> None:
         """
         Main concept here is that in init we do not connect to database,
         so that class instances can be safely made regardless of connection statuss.
 
-        Remember to call await openPool() after creating instance to actually open the pool to the database
-        and also await closePool() to close the pool.
+        Remember to call await open_pool() after creating instance to actually open the pool to the database
+        and also await close_pool() to close the pool.
         """
 
-        super().__init__(dbConfig, connectionTimeout, instanceName)
+        super().__init__(db_config, connection_timeout, instance_name)
 
         # Set defaults
         if not "port" in self.config or not self.config["port"]:
@@ -639,19 +639,19 @@ class PgSQLWithPoolingAsync(DatabaseBackend):
         if not "pool_kwargs" in self.config or not self.config["pool_kwargs"]:
             self.config["pool_kwargs"] = {}
 
-        connStr = (
+        conn_str = (
             f"postgresql://{self.config['username']}:{self.config['password']}@{self.config['hostname']}:{self.config['port']}"
-            f"/{self.config['database']}?connect_timeout={self.connectionTimeout}&application_name={self.name}"
+            f"/{self.config['database']}?connect_timeout={self.connection_timeout}&application_name={self.name}"
             f"&sslmode={self.config['ssl']}"
         )
-        self.poolAsync = AsyncConnectionPool(
-            connStr,
+        self.pool_async = AsyncConnectionPool(
+            conn_str,
             open=False,
             min_size=2,
             max_size=self.config["maxconnections"],
             max_lifetime=20 * 60,
             max_idle=400,
-            timeout=self.connectionTimeout,
+            timeout=self.connection_timeout,
             reconnect_timeout=0,
             num_workers=4,
             connection_class=PgConnectionTypeAsync,
@@ -663,27 +663,27 @@ class PgSQLWithPoolingAsync(DatabaseBackend):
         """Destructor"""
         del self.cursor
         del self.connection
-        del self.poolAsync
+        del self.pool_async
 
     ##################
     ### Connection ###
     ##################
 
-    async def openPool(self) -> None:
-        await self.poolAsync.open(wait=True, timeout=self.connectionTimeout)
+    async def open_pool(self) -> None:
+        await self.pool_async.open(wait=True, timeout=self.connection_timeout)
 
-    async def closePool(self) -> None:
+    async def close_pool(self) -> None:
         """Close Pool"""
 
-        if self.shutdownRequested.is_set():
+        if self.shutdown_requested.is_set():
             return
-        self.shutdownRequested.set()
+        self.shutdown_requested.set()
 
         # Close async pool
         self.logger.debug("Closing connection pool")
         await self.close()
-        if hasattr(self, "poolAsync") and self.poolAsync.closed is False:
-            await self.poolAsync.close()
+        if hasattr(self, "poolAsync") and self.pool_async.closed is False:
+            await self.pool_async.close()
 
     async def open(self) -> None:
         """Get connection from the pool and keep it in the class"""
@@ -691,7 +691,7 @@ class PgSQLWithPoolingAsync(DatabaseBackend):
             await self.close()
 
         # Create new connection
-        res = await self.newConnection()
+        res = await self.new_connection()
         if res:
             (self.connection, self.cursor) = res
 
@@ -704,29 +704,29 @@ class PgSQLWithPoolingAsync(DatabaseBackend):
             self.cursor = None
 
         if self.connection:
-            await self.returnConnection(self.connection)
+            await self.return_connection(self.connection)
             self.connection = None
 
-    async def newConnection(
+    async def new_connection(
         self,
     ) -> tuple[PgConnectionTypeAsync, PgCursorTypeAsync] | None:
-        assert self.poolAsync, "Async pool is not initialized"
+        assert self.pool_async, "Async pool is not initialized"
 
         # Log
         self.logger.debug("Getting connection from the pool")
 
         # Get connection from the pool
         tries = 0
-        while not self.shutdownRequested.is_set():
+        while not self.shutdown_requested.is_set():
             connection = None
             try:
-                connection = await self.poolAsync.getconn(
-                    timeout=self.connectionTimeout
+                connection = await self.pool_async.getconn(
+                    timeout=self.connection_timeout
                 )
                 cursor = connection.cursor(row_factory=PgDictRowFactory)
 
                 # Lets do some socket magic
-                self.fixSocketTimeouts(connection.fileno())
+                self.fix_socket_timeouts(connection.fileno())
 
                 async with connection.transaction():
                     await cursor.execute("SELECT 1")
@@ -737,10 +737,10 @@ class PgSQLWithPoolingAsync(DatabaseBackend):
             except Exception as e:
                 if connection:
                     await connection.close()
-                    await self.poolAsync.putconn(connection)
+                    await self.pool_async.putconn(connection)
 
                 self.logger.error(f"Error while getting connection from the pool: {e}")
-                self.shutdownRequested.wait(self.slowDownTimeout)
+                self.shutdown_requested.wait(self.slow_down_timeout)
                 tries += 1
                 if tries >= 3:
                     break
@@ -748,18 +748,18 @@ class PgSQLWithPoolingAsync(DatabaseBackend):
 
         return None
 
-    async def returnConnection(self, connection: PgConnectionTypeAsync) -> None:
+    async def return_connection(self, connection: PgConnectionTypeAsync) -> None:
         """Return connection to the pool"""
-        assert self.poolAsync, "Async pool is not initialized"
+        assert self.pool_async, "Async pool is not initialized"
 
         # Log
         self.logger.debug("Putting connection back to the pool")
 
         # Put connection back to the pool
-        await self.poolAsync.putconn(connection)
+        await self.pool_async.putconn(connection)
 
         # Debug
-        self.logger.debug(self.poolAsync.get_stats())
+        self.logger.debug(self.pool_async.get_stats())
 
     ###############
     ### Context ###
@@ -771,11 +771,11 @@ class PgSQLWithPoolingAsync(DatabaseBackend):
         """Context manager"""
 
         # Lets set the context var so that it is set even if we fail to get connection
-        self.contextConnectionAsync.set(None)
+        self.context_connection_async.set(None)
 
-        res = await self.newConnection()
+        res = await self.new_connection()
         if res:
-            self.contextConnectionAsync.set(res)
+            self.context_connection_async.set(res)
             return res
 
         return (
@@ -786,12 +786,12 @@ class PgSQLWithPoolingAsync(DatabaseBackend):
     async def __aexit__(self, exc_type: Any, exc_value: Any, traceback: Any) -> None:
         """Context manager"""
 
-        testData = self.contextConnectionAsync.get()
-        if testData:
-            await self.returnConnection(testData[0])
+        test_data = self.context_connection_async.get()
+        if test_data:
+            await self.return_connection(test_data[0])
 
         # Reset context
-        self.contextConnectionAsync.set(None)
+        self.context_connection_async.set(None)
 
     ####################
     ### Transactions ###
@@ -800,11 +800,11 @@ class PgSQLWithPoolingAsync(DatabaseBackend):
     @asynccontextmanager
     async def transaction(
         self,
-        dbConn: PgConnectionTypeAsync | None = None,
+        db_conn: PgConnectionTypeAsync | None = None,
     ) -> AsyncIterator[AsyncTransaction]:
         """Transaction context manager"""
-        if dbConn:
-            async with dbConn.transaction() as trans:
+        if db_conn:
+            async with db_conn.transaction() as trans:
                 yield trans
 
         assert self.connection, "Connection is not initialized"
@@ -815,7 +815,7 @@ class PgSQLWithPoolingAsync(DatabaseBackend):
     ### Data ###
     ############
 
-    def affectedRows(self) -> int:
+    def affected_rows(self) -> int:
         assert self.cursor, "Cursor is not initialized"
 
         return self.cursor.rowcount

database_wrapper_pgsql/db_wrapper_pgsql.py

@@ -13,7 +13,7 @@ class DBWrapperPgSQL(DBWrapperPgSQLMixin, DBWrapper):
     Sync database wrapper for postgres
     """
 
-    dbCursor: PgCursorType | None
+    db_cursor: PgCursorType | None
     """ PostgreSQL cursor object """
 
     #######################
@@ -24,36 +24,36 @@ class DBWrapperPgSQL(DBWrapperPgSQLMixin, DBWrapper):
     # We are overriding the __init__ method for the type hinting
     def __init__(
         self,
-        dbCursor: PgCursorType | None = None,
+        db_cursor: PgCursorType | None = None,
         logger: logging.Logger | None = None,
     ):
         """
         Initializes a new instance of the DBWrapper class.
 
         Args:
-            dbCursor (PgCursorType): The PostgreSQL database cursor object.
+            db_cursor (PgCursorType): The PostgreSQL database cursor object.
             logger (logging.Logger, optional): The logger object. Defaults to None.
         """
-        super().__init__(dbCursor, logger)
+        super().__init__(db_cursor, logger)
 
     ###############
     ### Setters ###
     ###############
 
-    def setDbCursor(self, dbCursor: PgCursorType | None) -> None:
+    def set_db_cursor(self, db_cursor: PgCursorType | None) -> None:
         """
         Updates the database cursor object.
 
         Args:
-            dbCursor (PgCursorType): The new database cursor object.
+            db_cursor (PgCursorType): The new database cursor object.
         """
-        super().setDbCursor(dbCursor)
+        super().set_db_cursor(db_cursor)
 
     ######################
     ### Helper methods ###
     ######################
 
-    def logQuery(
+    def log_query(
         self,
         cursor: Cursor[Any],
         query: sql.SQL | sql.Composed,
@@ -67,5 +67,5 @@ class DBWrapperPgSQL(DBWrapperPgSQLMixin, DBWrapper):
             query (Any): The query to log.
             params (tuple[Any, ...]): The parameters to log.
         """
-        queryString = query.as_string(self.dbCursor)
-        logging.getLogger().debug(f"Query: {queryString} with params: {params}")
+        query_string = query.as_string(self.db_cursor)
+        logging.getLogger().debug(f"Query: {query_string} with params: {params}")

database_wrapper_pgsql/db_wrapper_pgsql_async.py

@@ -15,7 +15,7 @@ class DBWrapperPgSQLAsync(DBWrapperPgSQLMixin, DBWrapperAsync):
     This is meant to be used in async environments.
     """
 
-    dbCursor: PgCursorTypeAsync | None
+    db_cursor: PgCursorTypeAsync | None
     """ Async PostgreSQL cursor object """
 
     #######################
@@ -26,36 +26,36 @@ class DBWrapperPgSQLAsync(DBWrapperPgSQLMixin, DBWrapperAsync):
     # We are overriding the __init__ method for the type hinting
     def __init__(
         self,
-        dbCursor: PgCursorTypeAsync | None = None,
+        db_cursor: PgCursorTypeAsync | None = None,
         logger: logging.Logger | None = None,
     ):
         """
         Initializes a new instance of the DBWrapper class.
 
         Args:
-            dbCursor (PgCursorTypeAsync): The PostgreSQL database cursor object.
+            db_cursor (PgCursorTypeAsync): The PostgreSQL database cursor object.
             logger (logging.Logger, optional): The logger object. Defaults to None.
         """
-        super().__init__(dbCursor, logger)
+        super().__init__(db_cursor, logger)
 
     ###############
     ### Setters ###
     ###############
 
-    def setDbCursor(self, dbCursor: PgCursorTypeAsync | None) -> None:
+    def set_db_cursor(self, db_cursor: PgCursorTypeAsync | None) -> None:
         """
         Updates the database cursor object.
 
         Args:
-            dbCursor (PgCursorTypeAsync): The new database cursor object.
+            db_cursor (PgCursorTypeAsync): The new database cursor object.
         """
-        super().setDbCursor(dbCursor)
+        super().set_db_cursor(db_cursor)
 
     ######################
     ### Helper methods ###
     ######################
 
-    def logQuery(
+    def log_query(
         self,
         cursor: PgCursorTypeAsync,
         query: sql.SQL | sql.Composed,
@@ -69,5 +69,5 @@ class DBWrapperPgSQLAsync(DBWrapperPgSQLMixin, DBWrapperAsync):
             query (Any): The query to log.
             params (tuple[Any, ...]): The parameters to log.
         """
-        queryString = query.as_string(self.dbCursor)
-        logging.getLogger().debug(f"Query: {queryString} with params: {params}")
+        query_string = query.as_string(self.db_cursor)
+        logging.getLogger().debug(f"Query: {query_string} with params: {params}")

database_wrapper_pgsql/db_wrapper_pgsql_mixin.py

@@ -13,7 +13,7 @@ class DBWrapperPgSQLMixin:
     ### Helper methods ###
     ######################
 
-    def makeIdentifier(self, schema: str | None, name: str) -> sql.Identifier | str:
+    def make_identifier(self, schema: str | None, name: str) -> sql.Identifier | str:
         """
         Creates a SQL identifier object from the given name.
 
@@ -32,50 +32,50 @@ class DBWrapperPgSQLMixin:
     ### Query methods ###
     #####################
 
-    def filterQuery(
+    def filter_query(
         self,
-        schemaName: str | None,
-        tableName: str,
+        schema_name: str | None,
+        table_name: 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.
+            schema_name (str): The name of the schema to filter data from.
+            table_name (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)
+            table=self.make_identifier(schema_name, table_name),
         )
 
-    def orderQuery(
+    def order_query(
         self,
-        orderBy: OrderByItem | None = None,
+        order_by: OrderByItem | None = None,
     ) -> sql.SQL | sql.Composed | 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.
 
         TODO: Fix return type
         """
-        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 sql.SQL("ORDER BY %s" % ", ".join(orderList))  # type: ignore
+        return sql.SQL("ORDER BY %s" % ", ".join(order_list))  # type: ignore
 
-    def limitQuery(
+    def limit_query(
         self,
         offset: int = 0,
         limit: int = 100,
@@ -85,29 +85,29 @@ class DBWrapperPgSQLMixin:
 
         return sql.SQL("LIMIT {} OFFSET {}").format(limit, offset)
 
-    def formatFilter(self, key: str, filter: Any) -> tuple[Any, ...]:
+    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().formatFilter(key, filter)  # type: ignore
+        return super().format_filter(key, filter)  # type: ignore
 
-    def createFilter(
+    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())
 
-        raw = [self.formatFilter(key, filter[key]) for key in filter]
+        raw = [self.format_filter(key, filter[key]) for key in filter]
 
-        _queryItems = sql.SQL(" AND ").join([sql.SQL(tup[0]) for tup in raw])
-        _query = sql.SQL("WHERE {queryItems}").format(queryItems=_queryItems)
+        _query_items = sql.SQL(" AND ").join([sql.SQL(tup[0]) for tup in raw])
+        _query = sql.SQL("WHERE {queryItems}").format(query_items=_query_items)
         _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: sql.SQL | sql.Composed | str,
-        qFilter: sql.SQL | sql.Composed | None,
+        q_filter: sql.SQL | sql.Composed | None,
         order: sql.SQL | sql.Composed | None,
         limit: sql.SQL | sql.Composed | None,
     ) -> sql.Composed:
@@ -115,57 +115,58 @@ class DBWrapperPgSQLMixin:
         if isinstance(query, str):
             query = sql.SQL(query)  # type: ignore
 
-        queryParts: list[sql.Composable] = [query]
-        if qFilter is not None:
-            # if isinstance(qFilter, str):
-            #     qFilter = sql.SQL(qFilter)
-            queryParts.append(qFilter)
+        query_parts: list[sql.Composable] = [query]
+        if q_filter is not None:
+            # if isinstance(q_filter, str):
+            #     q_filter = sql.SQL(q_filter)
+            query_parts.append(q_filter)
         if order is not None:
-            queryParts.append(order)
+            query_parts.append(order)
         if limit is not None:
-            queryParts.append(limit)
+            query_parts.append(limit)
 
-        return sql.SQL(" ").join(queryParts)
+        return sql.SQL(" ").join(query_parts)
 
-    def _formatInsertQuery(
+    def _format_insert_query(
         self,
-        tableIdentifier: sql.Identifier | str,
-        storeData: dict[str, Any],
-        returnKey: sql.Identifier | str,
+        table_identifier: sql.Identifier | str,
+        store_data: dict[str, Any],
+        return_key: sql.Identifier | str,
     ) -> sql.Composed:
-        keys = storeData.keys()
-        values = list(storeData.values())
+        keys = store_data.keys()
+        values = list(store_data.values())
 
         return sql.SQL(
             "INSERT INTO {table} ({columns}) VALUES ({values}) RETURNING {id_key}"
         ).format(
-            table=tableIdentifier,
+            table=table_identifier,
             columns=sql.SQL(", ").join(map(sql.Identifier, keys)),
             values=sql.SQL(", ").join(sql.Placeholder() * len(values)),
-            id_key=returnKey,
+            id_key=return_key,
         )
 
-    def _formatUpdateQuery(
+    def _format_update_query(
         self,
-        tableIdentifier: sql.Identifier | str,
-        updateKey: sql.Identifier | str,
-        updateData: dict[str, Any],
+        table_identifier: sql.Identifier | str,
+        update_key: sql.Identifier | str,
+        update_data: dict[str, Any],
     ) -> sql.Composed:
-        keys = updateData.keys()
+        keys = update_data.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=tableIdentifier,
+            table=table_identifier,
             set_clause=set_clause,
-            id_key=updateKey,
+            id_key=update_key,
         )
 
-    def _formatDeleteQuery(
+    def _format_delete_query(
         self,
-        tableIdentifier: sql.Identifier | str,
-        deleteKey: sql.Identifier | str,
+        table_identifier: sql.Identifier | str,
+        delete_key: sql.Identifier | str,
     ) -> sql.Composed:
         return sql.SQL("DELETE FROM {table} WHERE {id_key} = %s").format(
-            table=tableIdentifier, id_key=deleteKey
+            table=table_identifier,
+            id_key=delete_key,
         )

{database_wrapper_pgsql-0.1.85.dist-info → database_wrapper_pgsql-0.2.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: database_wrapper_pgsql
-Version: 0.1.85
+Version: 0.2.2
 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.85
+Requires-Dist: database_wrapper==0.2.2
 Requires-Dist: psycopg[binary]>=3.2.0
 Requires-Dist: psycopg[pool]>=3.2.0
 

database_wrapper_pgsql-0.2.2.dist-info/RECORD

@@ -0,0 +1,10 @@
+database_wrapper_pgsql/__init__.py,sha256=9QvHYUq5EgEpqIaZArrm30v_USM5zIaf0UN-z6cHWhs,1058
+database_wrapper_pgsql/connector.py,sha256=Hicf9DHxOjv6H77ySdTi26YmKjlSTzOIWQrjETq3LRg,25027
+database_wrapper_pgsql/db_wrapper_pgsql.py,sha256=Tm18dzSOINz4Z8xHWynLCPf-HmD_SFP0PYVE8ZPd_A4,1921
+database_wrapper_pgsql/db_wrapper_pgsql_async.py,sha256=d4AZp_dHdmob7oJlEst2DnhMqpeXeG6WOzI8k5OldKg,2024
+database_wrapper_pgsql/db_wrapper_pgsql_mixin.py,sha256=KOlKXNpTeEGL_IkCIyh-kcoCvxUbUKAFjdeYlFe1iVs,5451
+database_wrapper_pgsql/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+database_wrapper_pgsql-0.2.2.dist-info/METADATA,sha256=tsD8rkAo7w_UrW5Q6VxgXpDxOcM3wjggIjqlxhPGxFE,3229
+database_wrapper_pgsql-0.2.2.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+database_wrapper_pgsql-0.2.2.dist-info/top_level.txt,sha256=EQhZLk12wRdsSp-Lo3Jc4cXmNfG8y5EouNv_7OBCSGo,23
+database_wrapper_pgsql-0.2.2.dist-info/RECORD,,

{database_wrapper_pgsql-0.1.85.dist-info → database_wrapper_pgsql-0.2.2.dist-info}/WHEEL

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

database_wrapper_pgsql-0.1.85.dist-info/RECORD

@@ -1,10 +0,0 @@
-database_wrapper_pgsql/__init__.py,sha256=9QvHYUq5EgEpqIaZArrm30v_USM5zIaf0UN-z6cHWhs,1058
-database_wrapper_pgsql/connector.py,sha256=Qom_I8eVuq9iSHZEe06QW53oq16j0lmPLwPmcOrbKmc,24896
-database_wrapper_pgsql/db_wrapper_pgsql.py,sha256=v4GGsheZljELurAuaQDTI6ZFoFGjThQ9MubRpRj3dVc,1906
-database_wrapper_pgsql/db_wrapper_pgsql_async.py,sha256=sSCHLHvKnf7i_Dy8K8_XKa6hWMc26W9hJqU4nbN0v_c,2009
-database_wrapper_pgsql/db_wrapper_pgsql_mixin.py,sha256=D0RKSGnZsyC3XbhQeGgblCP3W9530at2j9O5CaSc2GI,5377
-database_wrapper_pgsql/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-database_wrapper_pgsql-0.1.85.dist-info/METADATA,sha256=mYMejIV0lsmsTreRiwb6XGxudu09LtScWQ4V03ob5cw,3231
-database_wrapper_pgsql-0.1.85.dist-info/WHEEL,sha256=SmOxYU7pzNKBqASvQJ7DjX3XGUF92lrGhMb3R6_iiqI,91
-database_wrapper_pgsql-0.1.85.dist-info/top_level.txt,sha256=EQhZLk12wRdsSp-Lo3Jc4cXmNfG8y5EouNv_7OBCSGo,23
-database_wrapper_pgsql-0.1.85.dist-info/RECORD,,