database-postgresql-local 0.1.2.1234__tar.gz → 0.1.3b4665__tar.gz

{database_postgresql_local-0.1.2.1234 → database_postgresql_local-0.1.3b4665}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: database-postgresql-local
-Version: 0.1.2.1234
+Version: 0.1.3b4665
 Summary: PyPI Package for Circles database-postgresql-local Python
 Home-page: https://github.com/circles-zone/database-postgresql-local-python-package
 Author: Circles
@@ -10,7 +10,7 @@ Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
 Requires-Dist: python-sdk-remote
 Requires-Dist: logger-local
-Requires-Dist: psycopg2
+Requires-Dist: psycopg2-binary
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

database_postgresql_local-0.1.3b4665/README.md

@@ -0,0 +1,10 @@
+# Database PostgreSQL Local Python Package
+
+TODO Please update the README of the package.<br>
+
+## TODOs
+
+TODO dynamic permission to certain columns to certain users.<br>
+
+TODO Enforce the GenericCrud interface on GenericCrudPostgres<br>
+TODO Enforce the GenericCrudMl interface on GenericCrudMlPostgres<br>

{database_postgresql_local-0.1.2.1234 → database_postgresql_local-0.1.3b4665}/database_postgresql_local/src/connector.py

@@ -2,21 +2,24 @@ from __future__ import annotations  # Required for type hinting in class methods
 
 from collections import defaultdict
 from os.path import expanduser
-from typing import Optional
+from typing import Any, Optional
 
 import psycopg2
 from psycopg2 import pool
+from logger_local import Logger
 from logger_local.MetaLogger import MetaLogger
 
 from .constants_src import LOGGER_CONNECTOR_CODE_OBJECT
-from .cursor import Cursor
+from . import cursor as cursor_module
 from .utils import (get_sql_hostname, get_sql_password, get_sql_username, get_sql_port)
 
-connections_pool = defaultdict(dict)
+connections_pool: defaultdict[str, dict] = defaultdict(dict)
 home = expanduser('~')
 
 
-class Connector(metaclass=MetaLogger, object=LOGGER_CONNECTOR_CODE_OBJECT):
+class Connector(metaclass=MetaLogger, object=LOGGER_CONNECTOR_CODE_OBJECT):  # type: ignore[call-arg]  # MetaLogger takes `object`
+    logger: Logger  # Set by MetaLogger
+
     @staticmethod
     def connect(schema_name: str, *, user: str = get_sql_username(), ignore_cache: bool = False) -> Connector:
         if ignore_cache and schema_name in connections_pool[user]:
@@ -59,8 +62,8 @@ class Connector(metaclass=MetaLogger, object=LOGGER_CONNECTOR_CODE_OBJECT):
         if not (self.host.endswith("circ.zone") or self.host.endswith("circlez.ai")):
             self.logger.warning(
                 f"Your POSTGRESQL_HOSTNAME={self.host} which is not what is expected")
-        self.connection = None
-        self._cursor = None
+        self.connection: Any = None
+        self._cursor: Any = None
         self._connect_to_db()
         connections_pool[user][schema_name] = self
 
@@ -108,12 +111,12 @@ class Connector(metaclass=MetaLogger, object=LOGGER_CONNECTOR_CODE_OBJECT):
             except:
                 pass
 
-    def cursor(self, *, close_previous: bool = True, cache_previous: bool = False, dictionary: bool = None,
-               buffered: bool = None, raw: bool = None,
-               prepared: bool = None, named_tuple: bool = None, cursor_class=None) -> Cursor:
+    def cursor(self, *, close_previous: bool = True, cache_previous: bool = False, dictionary: Optional[bool] = None,
+               buffered: Optional[bool] = None, raw: Optional[bool] = None,
+               prepared: Optional[bool] = None, named_tuple: Optional[bool] = None, cursor_class=None) -> cursor_module.Cursor:
         # PostgreSQL doesn't support all the same cursor options as MySQL
         # We'll create a basic cursor and wrap it in our Cursor class
-        cursor_instance = Cursor(self.connection.cursor())
+        cursor_instance = cursor_module.Cursor(self.connection.cursor())
         return cursor_instance
 
     def commit(self) -> None:

{database_postgresql_local-0.1.2.1234 → database_postgresql_local-0.1.3b4665}/database_postgresql_local/src/cursor.py

@@ -1,24 +1,27 @@
-from typing import Any
+from typing import Any, Optional
 
+from logger_local import Logger
 from logger_local.MetaLogger import MetaLogger
 from psycopg2.extensions import cursor as PostgreSQLCursor
 import psycopg2
 from .constants_src import LOGGER_CONNECTOR_CODE_OBJECT
 
 # PostgreSQL version
-POSTGRESQL_VERSION = psycopg2.__version__
+POSTGRESQL_VERSION = psycopg2.__version__  # type: ignore[attr-defined]  # Not in the psycopg2 type stubs
 
 
 def version_tuple(version):
     return tuple(map(int, version.split(".")))  # Converts "2.9.5" → (2, 9, 5)
 
 
-class Cursor(metaclass=MetaLogger, object=LOGGER_CONNECTOR_CODE_OBJECT):
+class Cursor(metaclass=MetaLogger, object=LOGGER_CONNECTOR_CODE_OBJECT):  # type: ignore[call-arg]  # MetaLogger takes `object`
+    logger: Logger  # Set by MetaLogger
+
     def __init__(self, cursor: PostgreSQLCursor) -> None:
         self.cursor = cursor
         self.__is_closed = False
 
-    def execute(self, sql_statement: str, sql_parameters: tuple | list = None, multi: bool = False) -> None:
+    def execute(self, sql_statement: str, sql_parameters: Optional[tuple | list] = None, multi: bool = False) -> None:
         # PostgreSQL doesn't support the multi parameter
         # Convert MySQL-style backtick quotes to PostgreSQL double quotes
         sql_statement = sql_statement.replace('`', '"')
@@ -43,7 +46,7 @@ class Cursor(metaclass=MetaLogger, object=LOGGER_CONNECTOR_CODE_OBJECT):
             self.logger.error(f"Error executing SQL: {e}")
             raise
 
-    def executemany(self, sql_statement: str, sql_parameters: tuple | list = None) -> None:
+    def executemany(self, sql_statement: str, sql_parameters: Optional[tuple | list] = None) -> None:
         try:
             # Convert MySQL-style backtick quotes to PostgreSQL double quotes
             sql_statement = sql_statement.replace('`', '"')
@@ -61,7 +64,7 @@ class Cursor(metaclass=MetaLogger, object=LOGGER_CONNECTOR_CODE_OBJECT):
                 "sql_statement": sql_statement.replace("\n", " ")
             })
             
-            self.cursor.executemany(sql_statement, sql_parameters)
+            self.cursor.executemany(sql_statement, sql_parameters or [])
         except Exception as e:
             self.logger.warning('Unable to execute statement', object={
                 "sql_statement": sql_statement,
@@ -82,7 +85,7 @@ class Cursor(metaclass=MetaLogger, object=LOGGER_CONNECTOR_CODE_OBJECT):
         result = self.cursor.fetchone()
         return result
 
-    def description(self) -> list[tuple]:
+    def description(self) -> Optional[tuple]:
         """Returns description of columns in a result
 
         This property returns a list of tuples describing the columns
@@ -112,7 +115,8 @@ class Cursor(metaclass=MetaLogger, object=LOGGER_CONNECTOR_CODE_OBJECT):
         # This is a simplified implementation that may need to be adjusted based on actual usage
         try:
             self.cursor.execute("SELECT lastval()")
-            result = self.cursor.fetchone()[0]
+            row = self.cursor.fetchone()
+            result = row[0] if row else None
             return result
         except Exception as e:
             self.logger.warning(f"Error getting lastrowid: {e}")

{database_postgresql_local-0.1.2.1234 → database_postgresql_local-0.1.3b4665}/database_postgresql_local/src/generic_crud_postgresql.py

@@ -1,6 +1,6 @@
 from datetime import datetime, timezone
 from functools import lru_cache
-from typing import Any, Optional
+from typing import Any, Optional, Sequence
 
 import psycopg2
 from database_infrastructure_local.number_generator import NumberGenerator
@@ -10,13 +10,13 @@ from logger_local.MetaLogger import ABCMetaLogger
 from user_context_remote.user_context import UserContext
 from python_sdk_remote.our_object import OurObject
 
-from .connector import Connector
+from . import connector as connector_module
 from .constants_src import CRUD_POSTGRESQL_CODE_LOGGER_OBJECT
-from .cursor import Cursor
+from . import cursor as cursor_module
 from .table_definition import table_definition
 from .utils import (detect_if_is_test_data, generate_id_column_name,
                     generate_table_name, generate_view_name,
-                    get_entity_type_id_by_table_name, get_where_params,
+                    get_entity_type_by_table_name, get_where_params,
                     process_insert_data_dict, process_update_data_dict,
                     process_upsert_data_dict,
                     replace_view_with_table, validate_none_select_table_name,
@@ -31,41 +31,38 @@ from .utils import (detect_if_is_test_data, generate_id_column_name,
 
 
 class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
-                            object=CRUD_POSTGRESQL_CODE_LOGGER_OBJECT):
+                           object=CRUD_POSTGRESQL_CODE_LOGGER_OBJECT):  # type: ignore[call-arg]  # MetaLogger takes `object`
     """A class that provides generic CRUD functionality for PostgreSQL databases.
     There are 4 main functions to create, read, update, and delete data from the database.
     The rest of the functions are helper functions or wrappers around the main functions."""
 
     def __init__(self, *, default_schema_name: str,
-                 default_table_name: str = None,
-                 default_view_table_name: str = None,
-                 default_view_with_deleted_and_test_data: str = None,
-                 default_column_name: str = None,
+                 default_table_name: Optional[str] = None,
+                 default_view_table_name: Optional[str] = None,
+                 default_view_with_deleted_and_test_data: Optional[str] = None,
+                 default_column_name: Optional[str] = None,
                  default_select_clause_value: str = "*",
-                 default_where: str = None,
+                 default_where: Optional[str] = None,
                  is_test_data: bool = False) -> None:
         """Initializes the GenericCrudPostgresql class. If a connection is not provided, a new connection will be created."""
         self.default_schema_name = default_schema_name
         # We do not need a connection per schema, and it makes terrible performance.
         # In special cases, you can always use set_schema.
-        self.connection = Connector.connect(schema_name=default_schema_name)
+        self.connection = connector_module.Connector.connect(schema_name=default_schema_name)
         self._cursor = self.connection.cursor()
         self.default_table_name = default_table_name or generate_table_name(default_schema_name)
-        self.default_view_table_name = default_view_table_name \
-            or generate_view_name(
-                self.default_table_name)
-        self.default_column_name = default_column_name \
-            or generate_id_column_name(self.default_table_name)
-        self.default_view_with_deleted_and_test_data = \
-            default_view_with_deleted_and_test_data
+        self.default_view_table_name = default_view_table_name or generate_view_name(
+            self.default_table_name)
+        self.default_column_name = default_column_name or generate_id_column_name(self.default_table_name)
+        self.default_view_with_deleted_and_test_data = default_view_with_deleted_and_test_data
         self.default_select_clause_value = default_select_clause_value
         self.default_where = default_where
         self.is_test_data = is_test_data or detect_if_is_test_data()
         self.is_ignore_duplicate = False
         self.user_context = UserContext()
 
-    def insert(self, *, schema_name: str = None, table_name: str = None, data_dict: dict = None,
-               ignore_duplicate: bool = False, commit_changes: bool = True) -> int:
+    def insert(self, *, schema_name: Optional[str] = None, table_name: Optional[str] = None, data_dict: Optional[dict] = None,
+               ignore_duplicate: bool = False, commit_changes: bool = True) -> Optional[int]:
         """Inserts a new row into the table and returns the id of the new row or -1 if an error occurred.
         ignore_duplicate should be False as default, because for example if a user register with existing name,
             he should get an error and not existing id
@@ -78,8 +75,7 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
                              object={"data_dict": data_dict})
 
         data_dict = self.__add_create_updated_user_profile_ids(
-            data_dict=data_dict, add_created_user_id=True,
-            schema_name=schema_name, table_name=table_name)
+            data_dict=data_dict, add_created_user_id=True, schema_name=schema_name, table_name=table_name)
 
         columns, values, params = process_insert_data_dict(data_dict=data_dict)
         
@@ -131,9 +127,8 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
     def __get_existing_duplicate_id_with_undelete(
             self, schema_name: str, table_name: str, data_dict: dict) -> int | None:
         column_name = generate_id_column_name(table_name)
-        where, params = self.get_constraint_where_clause(
-            schema_name=schema_name, table_name=table_name,
-            data_dict=data_dict)
+        where, params = self.get_constraint_where_clause(schema_name=schema_name, table_name=table_name,
+                                                         data_dict=data_dict)
         row = self.select_one_tuple_by_where(
             schema_name=schema_name, view_table_name=table_name,
             select_clause_value=f"{column_name}, end_timestamp",
@@ -175,16 +170,14 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
                     existing_duplicate_id = None
         else:
             existing_duplicate_id = self.select_one_value_by_where(
-                schema_name=schema_name, view_table_name=table_name,
-                select_clause_value=column_name,
+                schema_name=schema_name, view_table_name=table_name, select_clause_value=column_name,
                 where=where, params=params)
         return existing_duplicate_id
-
     def update_by_column_and_value(
-            self, *, schema_name: str = None, table_name: str = None,
-            column_name: str = None, column_value: Any,
-            data_dict: dict = None,
-            limit: int = DEFAULT_SQL_SELECT_LIMIT, order_by: str = None,
+            self, *, schema_name: Optional[str] = None, table_name: Optional[str] = None,
+            column_name: Optional[str] = None, column_value: Any,
+            data_dict: Optional[dict] = None,
+            limit: int = DEFAULT_SQL_SELECT_LIMIT, order_by: Optional[str] = None,
             commit_changes: bool = True) -> int:
         """Updates data in the table by ID."""
 
@@ -201,96 +194,11 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
         else:
             raise Exception("Update by id requires an column_name")
 
-    def update_by_where(self, *, schema_name: str = None,
-                        table_name: str = None, where: str = None,
-                        params: tuple = None, data_dict: dict = None,
+    def update_by_where(self, *, schema_name: Optional[str] = None,
+                        table_name: Optional[str] = None, where: Optional[str] = None,
+                        params: Optional[tuple] = None, data_dict: Optional[dict] = None,
                         limit: int = DEFAULT_SQL_SELECT_LIMIT,
-                        order_by: str = None,
-                        commit_changes: bool = True) -> int:
-        """Updates data in the table by WHERE.
-        Example:
-        "UPDATE table_name SET A=A_val, B=B_val WHERE C=C_val AND D=D_val"
-        translates into:
-        update_by_where(table_name="table_name",
-                        data_dict={"A": A_val, "B": B_val},
-                        where="C=%s AND D=%s",
-                        params=(C_val, D_val)"
-        """
-
-        table_name = table_name or self.default_table_name
-        schema_name = schema_name or self.default_schema_name
-        self._validate_args(args=locals())
-
-        data_dict = self.__add_create_updated_user_profile_ids(data_dict=data_dict, add_created_user_id=False,
-                                                               schema_name=schema_name, table_name=table_name)
-
-        set_values, data_dict_params = process_update_data_dict(data_dict)
-        if not where:
-            raise Exception("update_by_where requires a 'where'")
-
-        # PostgreSQL doesn't support LIMIT in UPDATE without a subquery
-        # We'll handle this differently based on whether limit and order_by are provided
-        if limit != DEFAULT_SQL_SELECT_LIMIT or order_by:
-            # For PostgreSQL, we need to use a subquery with LIMIT and ORDER BY
-            id_column = generate_id_column_name(table_name)
-            
-            # First, get the IDs of rows to update
-            select_query = f'SELECT "{id_column}" FROM "{schema_name}"."{table_name}" WHERE {where}'
-            if order_by:
-                select_query += f' ORDER BY {order_by}'
-            if limit != DEFAULT_SQL_SELECT_LIMIT:
-                select_query += f' LIMIT {limit}'
-                
-            # Then update only those rows
-            if 'mapping' in self.default_table_name:
-                update_query = f'UPDATE "{schema_name}"."{table_name}" SET {set_values} ' \
-                              f'WHERE "{id_column}" IN ({select_query});'
-            else:
-                update_query = f'UPDATE "{schema_name}"."{table_name}" SET {set_values}, ' \
-                              f'updated_timestamp=CURRENT_TIMESTAMP ' \
-                              f'WHERE "{id_column}" IN ({select_query});'
-        else:
-            # Simple update without LIMIT or ORDER BY
-            if 'mapping' in self.default_table_name:
-                update_query = f'UPDATE "{schema_name}"."{table_name}" SET {set_values} WHERE {where};'
-            else:
-                update_query = f'UPDATE "{schema_name}"."{table_name}" SET {set_values}, ' \
-                              f'updated_timestamp=CURRENT_TIMESTAMP WHERE {where};'
-
-        where_params = params or tuple()
-
-        self.cursor.execute(update_query, data_dict_params + where_params)
-        if commit_changes:
-            self.connection.commit()
-        updated_rows = self.cursor.get_affected_row_count()
-        return updated_rows
-
-    def update_by_column_and_value(
-            self, *, schema_name: str = None, table_name: str = None,
-            column_name: str = None, column_value: Any,
-            data_dict: dict = None,
-            limit: int = DEFAULT_SQL_SELECT_LIMIT, order_by: str = None,
-            commit_changes: bool = True) -> int:
-        """Updates data in the table by ID."""
-
-        table_name = table_name or self.default_table_name
-        column_name = column_name or self.default_column_name
-
-        if column_name:
-            where, params = get_where_params(column_name, column_value)
-            updated_rows = self.update_by_where(
-                schema_name=schema_name, table_name=table_name, where=where, data_dict=data_dict,
-                params=params, limit=limit, order_by=order_by, commit_changes=commit_changes)
-            return updated_rows
-
-        else:
-            raise Exception("Update by id requires an column_name")
-
-    def update_by_where(self, *, schema_name: str = None,
-                        table_name: str = None, where: str = None,
-                        params: tuple = None, data_dict: dict = None,
-                        limit: int = DEFAULT_SQL_SELECT_LIMIT,
-                        order_by: str = None,
+                        order_by: Optional[str] = None,
                         commit_changes: bool = True) -> int:
         """Updates data in the table by WHERE.
         Example:
@@ -350,8 +258,8 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
         updated_rows = self.cursor.get_affected_row_count()
         return updated_rows
         
-    def delete_by_column_and_value(self, *, schema_name: str = None, table_name: str = None,
-                                   column_name: str = None, column_value: Any) -> int:
+    def delete_by_column_and_value(self, *, schema_name: Optional[str] = None, table_name: Optional[str] = None,
+                                   column_name: Optional[str] = None, column_value: Any) -> int:
         """Deletes data from the table by id.
         Returns the number of deleted rows."""
         # checks are done inside delete_by_where
@@ -365,8 +273,8 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
         else:
             raise Exception("Delete by id requires an column_name and column_value.")
 
-    def delete_by_where(self, *, schema_name: str = None, table_name: str = None, where: str = None,
-                        params: tuple = None) -> int:
+    def delete_by_where(self, *, schema_name: Optional[str] = None, table_name: Optional[str] = None, where: Optional[str] = None,
+                        params: Optional[tuple] = None) -> int:
         """Deletes data from the table by WHERE.
         Returns the number of deleted rows."""
 
@@ -388,8 +296,8 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
         deleted_rows = self.cursor.get_affected_row_count()
         return deleted_rows
         
-    def undelete_by_column_and_value(self, *, schema_name: str = None, table_name: str = None,
-                                     column_name: str = None, column_value: Any) -> None:
+    def undelete_by_column_and_value(self, *, schema_name: Optional[str] = None, table_name: Optional[str] = None,
+                                     column_name: Optional[str] = None, column_value: Any) -> None:
         """Undeletes a row by setting the end_timestamp to NULL."""
         schema_name = schema_name or self.default_schema_name
         table_name = table_name or self.default_table_name
@@ -401,9 +309,9 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
             data_dict={"end_timestamp": None})
     # Main select function
     def select_multi_tuple_by_where(
-            self, *, schema_name: str = None, view_table_name: str = None, select_clause_value: str = None,
-            where: str = None, params: tuple = None, distinct: bool = False, limit: int = DEFAULT_SQL_SELECT_LIMIT,
-            order_by: str = None) -> list:
+            self, *, schema_name: Optional[str] = None, view_table_name: Optional[str] = None, select_clause_value: Optional[str] = None,
+            where: Optional[str] = None, params: Optional[tuple] = None, distinct: bool = False, limit: int = DEFAULT_SQL_SELECT_LIMIT,
+            order_by: Optional[str] = None) -> list:
         """Selects multiple rows from the table based on a WHERE clause and returns them as a list of tuples."""
 
         schema_name = schema_name or self.default_schema_name
@@ -448,21 +356,22 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
         return result
 
     def select_multi_dict_by_where(
-            self, *, schema_name: str = None, view_table_name: str = None, select_clause_value: str = None,
-            where: str = None, params: tuple = None, distinct: bool = False, group_by: str = None,
-            limit: int = DEFAULT_SQL_SELECT_LIMIT, order_by: str = None) -> list | dict[tuple | str, list]:
+            self, *, schema_name: Optional[str] = None, view_table_name: Optional[str] = None, select_clause_value: Optional[str] = None,
+            where: Optional[str] = None, params: Optional[tuple] = None, distinct: bool = False, group_by: Optional[str] = None,
+            limit: int = DEFAULT_SQL_SELECT_LIMIT, order_by: Optional[str] = None) -> list | dict[tuple | str, list]:
         """Selects multiple rows from the table based on a WHERE clause and returns them as a list of dictionaries."""
         result = self.select_multi_tuple_by_where(
             schema_name=schema_name, view_table_name=view_table_name, select_clause_value=select_clause_value,
             where=where, params=params, distinct=distinct, limit=limit, order_by=order_by)
         result_as_dicts = self.convert_multi_to_dict(result, select_clause_value)
         if group_by:
-            result_as_dicts = group_list_by_columns(list_of_dicts=result_as_dicts, group_by=group_by)
+            grouped_result = group_list_by_columns(list_of_dicts=result_as_dicts, group_by=group_by)
+            return grouped_result
         return result_as_dicts
 
     def select_one_tuple_by_where(
-            self, *, schema_name: str = None, view_table_name: str = None, select_clause_value: str = None,
-            where: str = None, params: tuple = None, distinct: bool = False, order_by: str = None) -> tuple:
+            self, *, schema_name: Optional[str] = None, view_table_name: Optional[str] = None, select_clause_value: Optional[str] = None,
+            where: Optional[str] = None, params: Optional[tuple] = None, distinct: bool = False, order_by: Optional[str] = None) -> tuple:
         """Selects one row from the table based on a WHERE clause and returns it as a tuple."""
         result = self.select_multi_tuple_by_where(
             schema_name=schema_name, view_table_name=view_table_name, select_clause_value=select_clause_value,
@@ -474,18 +383,18 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
         return tuple_result
 
     def select_one_dict_by_where(
-            self, *, schema_name: str = None, view_table_name: str = None, select_clause_value: str = None,
-            where: str = None, params: tuple = None, distinct: bool = False, order_by: str = None) -> dict:
+            self, *, schema_name: Optional[str] = None, view_table_name: Optional[str] = None, select_clause_value: Optional[str] = None,
+            where: Optional[str] = None, params: Optional[tuple] = None, distinct: bool = False, order_by: Optional[str] = None) -> dict:
         """Selects one row from the table based on a WHERE clause and returns it as a dictionary."""
-        result = self.select_one_tuple_by_where(
+        row = self.select_one_tuple_by_where(
             schema_name=schema_name, view_table_name=view_table_name, select_clause_value=select_clause_value,
             where=where, params=params, distinct=distinct, order_by=order_by)
-        result = self.convert_to_dict(row=result, select_clause_value=select_clause_value)
+        result = self.convert_to_dict(row=row, select_clause_value=select_clause_value)
         return result
 
     def select_one_value_by_where(
-            self, *, select_clause_value: str, schema_name: str = None, view_table_name: str = None,
-            where: str = None, params: tuple = None, distinct: bool = False, order_by: str = None,
+            self, *, select_clause_value: str, schema_name: Optional[str] = None, view_table_name: Optional[str] = None,
+            where: Optional[str] = None, params: Optional[tuple] = None, distinct: bool = False, order_by: Optional[str] = None,
             skip_null_values: bool = True) -> Any:
         """Selects one value from the table based on a WHERE clause and returns it."""
         select_clause_value = select_clause_value or self.default_select_clause_value
@@ -500,9 +409,9 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
             value = None
         return value
     def select_one_tuple_by_column_and_value(
-            self, *, schema_name: str = None, view_table_name: str = None, select_clause_value: str = None,
-            column_name: str = None, column_value: Any,
-            distinct: bool = False, order_by: str = None) -> tuple:
+            self, *, schema_name: Optional[str] = None, view_table_name: Optional[str] = None, select_clause_value: Optional[str] = None,
+            column_name: Optional[str] = None, column_value: Any,
+            distinct: bool = False, order_by: Optional[str] = None) -> tuple:
         """Selects one row from the table by ID and returns it as a tuple."""
         result = self.select_multi_tuple_by_column_and_value(
             schema_name=schema_name, view_table_name=view_table_name, select_clause_value=select_clause_value,
@@ -514,20 +423,20 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
         return one_tuple_result
 
     def select_one_dict_by_column_and_value(
-            self, *, schema_name: str = None, view_table_name: str = None, select_clause_value: str = None,
-            column_name: str = None, column_value: Any,
-            distinct: bool = False, order_by: str = None) -> dict:
+            self, *, schema_name: Optional[str] = None, view_table_name: Optional[str] = None, select_clause_value: Optional[str] = None,
+            column_name: Optional[str] = None, column_value: Any,
+            distinct: bool = False, order_by: Optional[str] = None) -> dict:
         """Selects one row from the table by ID and returns it as a dictionary (column_name: value)"""
-        result = self.select_one_tuple_by_column_and_value(
+        row = self.select_one_tuple_by_column_and_value(
             schema_name=schema_name, view_table_name=view_table_name, select_clause_value=select_clause_value,
             column_name=column_name, column_value=column_value, distinct=distinct, order_by=order_by)
-        result = self.convert_to_dict(row=result, select_clause_value=select_clause_value)
+        result = self.convert_to_dict(row=row, select_clause_value=select_clause_value)
         return result
 
     def select_one_value_by_column_and_value(
-            self, *, select_clause_value: str = None, schema_name: str = None, view_table_name: str = None,
-            column_name: str = None, column_value: Any,
-            distinct: bool = False, order_by: str = None, skip_null_values: bool = True) -> Any:
+            self, *, select_clause_value: Optional[str] = None, schema_name: Optional[str] = None, view_table_name: Optional[str] = None,
+            column_name: Optional[str] = None, column_value: Any,
+            distinct: bool = False, order_by: Optional[str] = None, skip_null_values: bool = True) -> Any:
         """Selects one value from the table by ID and returns it."""
 
         column_name = column_name or self.default_column_name
@@ -545,9 +454,9 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
         return value
 
     def select_multi_tuple_by_column_and_value(
-            self, *, schema_name: str = None, view_table_name: str = None, select_clause_value: str = None,
-            column_name: str = None, column_value: Any,
-            distinct: bool = False, limit: int = DEFAULT_SQL_SELECT_LIMIT, order_by: str = None) -> list:
+            self, *, schema_name: Optional[str] = None, view_table_name: Optional[str] = None, select_clause_value: Optional[str] = None,
+            column_name: Optional[str] = None, column_value: Any,
+            distinct: bool = False, limit: int = DEFAULT_SQL_SELECT_LIMIT, order_by: Optional[str] = None) -> list:
         """Selects multiple rows from the table by ID and returns them as a list of tuples.
         If column_value is list / tuple, it will be used as multiple values for the column_name (SQL IN)."""
 
@@ -560,20 +469,21 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
         return result
 
     def select_multi_dict_by_column_and_value(
-            self, *, schema_name: str = None, view_table_name: str = None, select_clause_value: str = None,
-            column_name: str = None, column_value: Any,
-            distinct: bool = False, limit: int = DEFAULT_SQL_SELECT_LIMIT, order_by: str = None,
-            group_by: str = None) -> list | dict[tuple | str, list]:
+            self, *, schema_name: Optional[str] = None, view_table_name: Optional[str] = None, select_clause_value: Optional[str] = None,
+            column_name: Optional[str] = None, column_value: Any,
+            distinct: bool = False, limit: int = DEFAULT_SQL_SELECT_LIMIT, order_by: Optional[str] = None,
+            group_by: Optional[str] = None) -> list | dict[tuple | str, list]:
         """Selects multiple rows from the table by ID and returns them as a list of dictionaries."""
         result = self.select_multi_tuple_by_column_and_value(
             schema_name=schema_name, view_table_name=view_table_name, select_clause_value=select_clause_value,
             column_name=column_name, column_value=column_value, distinct=distinct, limit=limit, order_by=order_by)
         result_as_dicts = self.convert_multi_to_dict(result, select_clause_value)
         if group_by:
-            result_as_dicts = group_list_by_columns(list_of_dicts=result_as_dicts, group_by=group_by)
+            grouped_result = group_list_by_columns(list_of_dicts=result_as_dicts, group_by=group_by)
+            return grouped_result
         return result_as_dicts
-    def insert_if_not_exists(self, *, schema_name: str = None, table_name: str = None, data_dict: dict = None,
-                             data_dict_compare: dict = None, view_table_name: str = None,
+    def insert_if_not_exists(self, *, schema_name: Optional[str] = None, table_name: Optional[str] = None, data_dict: Optional[dict] = None,
+                             data_dict_compare: Optional[dict] = None, view_table_name: Optional[str] = None,
                              commit_changes: bool = True, compare_with_or: bool = False) -> int:
         """Inserts a new row into the table if a row with the same values does not exist,
         and returns the id of the new row | None if an error occurred."""
@@ -584,7 +494,7 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
         self._validate_args(args=locals())
 
         # Try to select
-        where_clause, params = process_upsert_data_dict(data_dict=data_dict_compare, compare_with_or=compare_with_or)
+        where_clause, params = process_upsert_data_dict(data_dict=data_dict_compare or {}, compare_with_or=compare_with_or)
         row_tuple = self.select_one_tuple_by_where(
             schema_name=schema_name, view_table_name=view_table_name, select_clause_value="*",
             where=where_clause, params=params)
@@ -599,7 +509,7 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
                              object={"id": entity_id})
         return entity_id
 
-    def insert_many_dicts(self, *, schema_name: str = None, table_name: str = None, data_dicts: list[dict],
+    def insert_many_dicts(self, *, schema_name: Optional[str] = None, table_name: Optional[str] = None, data_dicts: list[dict],
                           commit_changes: bool = True) -> int:
         """Inserts multiple rows into the table.
         data_dicts should be in the following format: [{col1: val1, col2: val2}, {col1: val3, col2: val4}, ...]
@@ -609,13 +519,13 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
             self.logger.warning("GenericCrudPostgresql.insert_many_dicts: data_dicts is empty")
             inserted_rows = 0
         else:
-            converted_data_dicts = {col: [row[col] for row in data_dicts] for col in data_dicts[0]}
+            converted_data_dicts: dict[str, list[Any] | tuple[Any, ...]] = {col: [row[col] for row in data_dicts] for col in data_dicts[0]}
             inserted_rows = self.insert_many(schema_name=schema_name, table_name=table_name,
                                              data_dict=converted_data_dicts, commit_changes=commit_changes)
 
         return inserted_rows
 
-    def insert_many(self, *, schema_name: str = None, table_name: str = None, data_dict: dict[str, list | tuple],
+    def insert_many(self, *, schema_name: Optional[str] = None, table_name: Optional[str] = None, data_dict: dict[str, list | tuple],
                     commit_changes: bool = True) -> int:
         """Inserts multiple rows into the table.
         data_dict should be in the following format: {col1: [val1, val2], col2: [val3, val4], ...}
@@ -648,9 +558,9 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
             self.connection.commit()
         inserted_rows = self.cursor.get_affected_row_count()
         return inserted_rows
-    def upsert_with_select_clause(self, *, schema_name: str = None, table_name: str = None, view_table_name: str = None,
-                                  data_dict: dict = None, where_compare: str = None, params_compare: tuple = None,
-                                  data_dict_compare: dict = None, order_by: str = None, compare_with_or: bool = False,
+    def upsert_with_select_clause(self, *, schema_name: Optional[str] = None, table_name: Optional[str] = None, view_table_name: Optional[str] = None,
+                                  data_dict: Optional[dict] = None, where_compare: Optional[str] = None, params_compare: Optional[tuple] = None,
+                                  data_dict_compare: Optional[dict] = None, order_by: Optional[str] = None, compare_with_or: bool = False,
                                   select_clause_value: str = "*") -> dict:
         """
         Inserts a new row into the table if a row with the same values does not exist,
@@ -667,7 +577,7 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
         view_table_name = view_table_name or self.default_view_table_name
         column_name = generate_id_column_name(table_name)
         self._validate_args(args=locals())
-        result_dict = {}
+        result_dict: dict = {}
         if not data_dict:
             self.logger.warning(log_message="GenericCrudPostgresql.upsert_with_select_clause: data_dict is empty")
             return result_dict
@@ -678,7 +588,7 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
             result_dict = data_dict
             return result_dict
 
-        where_clause, params = process_upsert_data_dict(data_dict=data_dict_compare, compare_with_or=compare_with_or,
+        where_clause, params = process_upsert_data_dict(data_dict=data_dict_compare or {}, compare_with_or=compare_with_or,
                                                         where_compare=where_compare, params_compare=params_compare)
         # Add table_id if it's not in select_clause_value
         if select_clause_value != "*" and column_name not in select_clause_value:
@@ -714,10 +624,10 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
         return result_dict
 
     # We want upsert to call upsert_with_select_clause, and return only the id
-    def upsert(self, *, schema_name: str = None, table_name: str = None, view_table_name: str = None,
-               data_dict: dict = None, where_compare: str = None,
-               params_compare: tuple = None, data_dict_compare: dict = None,
-               order_by: str = None, compare_with_or: bool = False) -> Optional[int]:
+    def upsert(self, *, schema_name: Optional[str] = None, table_name: Optional[str] = None, view_table_name: Optional[str] = None,
+               data_dict: Optional[dict] = None, where_compare: Optional[str] = None,
+               params_compare: Optional[tuple] = None, data_dict_compare: Optional[dict] = None,
+               order_by: Optional[str] = None, compare_with_or: bool = False) -> Optional[int]:
         """
         Inserts a new row into the table if a row with the same values does not exist,
         the "same values" are extracted from data_dict_compare.
@@ -736,18 +646,18 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
         inserted_id = inserted_id_per_column_dict[column_name]
         return inserted_id
     # Helper methods
-    def convert_to_dict(self, row: tuple, select_clause_value: str = None) -> dict:
+    def convert_to_dict(self, row: tuple, select_clause_value: Optional[str] = None) -> dict:
         """Returns a dictionary of the column names and their values."""
         select_clause_value = select_clause_value or self.default_select_clause_value
         if select_clause_value == "*":
-            column_names = self.cursor.column_names()
+            column_names: Sequence[str] = self.cursor.column_names()
         else:
             column_names = [x.strip() for x in select_clause_value.split(",")]
         dict_result = dict(zip(column_names, row or tuple()))
         self.logger.debug(object=locals())
         return dict_result
 
-    def convert_multi_to_dict(self, rows: list[tuple], select_clause_value: str = None) -> list[dict]:
+    def convert_multi_to_dict(self, rows: list[tuple], select_clause_value: Optional[str] = None) -> list[dict]:
         """Converts multiple rows to dictionaries."""
         multiple_dict_result = [self.convert_to_dict(row=row, select_clause_value=select_clause_value)
                                 for row in rows]
@@ -777,7 +687,7 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
             if message:
                 raise Exception(message)
 
-    def __where_security(self, where: str, view_name: str) -> str:
+    def __where_security(self, where: Optional[str], view_name: str) -> Optional[str]:
         """Adds security to the where clause."""
         if view_name in table_definition:
             if table_definition[view_name].get("is_visibility"):
@@ -788,8 +698,8 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
                 return where_security
         return where
 
-    def __add_create_updated_user_profile_ids(self, data_dict: dict, add_created_user_id: bool = False,
-                                              schema_name: str = None, table_name: str = None) -> dict:
+    def __add_create_updated_user_profile_ids(self, data_dict: Optional[dict], add_created_user_id: bool = False,
+                                              schema_name: Optional[str] = None, table_name: Optional[str] = None) -> dict:
         """Adds created_user_id and updated_user_id to data_dict."""
         data_dict = data_dict or {}
         schema_name = schema_name or self.default_schema_name
@@ -859,7 +769,7 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
 
     def __add_identifier(self, data_dict: dict, table_name: str) -> None:
         # If there's an "identifier" column in the table, we want to insert a random identifier
-        identifier_entity_type_id = get_entity_type_id_by_table_name(table_name)
+        identifier_entity_type_id = get_entity_type_by_table_name(table_name)
         if not identifier_entity_type_id:
             return
         identifier = NumberGenerator.get_random_identifier(
@@ -871,7 +781,7 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
         self.connection.commit()
 
     @lru_cache
-    def get_primary_key(self, schema_name: str = None, table_name: str = None) -> str | None:
+    def get_primary_key(self, schema_name: Optional[str] = None, table_name: Optional[str] = None) -> str | None:
         schema_name = schema_name or self.default_schema_name
         table_name = table_name or self.default_table_name
         query = """
@@ -929,7 +839,7 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
         return where, params
 
     @property
-    def cursor(self) -> Cursor:
+    def cursor(self) -> cursor_module.Cursor:
         """Get a new cursor"""
         if self._cursor.is_closed():
             self._cursor = self.connection.cursor()
@@ -937,7 +847,7 @@ class GenericCrudPostgresql(GenericCrudAbstract, metaclass=ABCMetaLogger,
         return cursor
 
     @cursor.setter
-    def cursor(self, value: Cursor) -> None:
+    def cursor(self, value: cursor_module.Cursor) -> None:
         """Set the cursor"""
         self._cursor = value
 

{database_postgresql_local-0.1.2.1234 → database_postgresql_local-0.1.3b4665}/database_postgresql_local/src/table_columns.py

@@ -1,4 +1,4 @@
 # Placeholder for table columns
 # This will be populated from the database schema
 
-table_columns = {}
+table_columns: dict = {}

{database_postgresql_local-0.1.2.1234 → database_postgresql_local-0.1.3b4665}/database_postgresql_local/src/table_definition.py

@@ -1,4 +1,4 @@
 # Placeholder for table definitions
 # This will be populated from the database schema
 
-table_definition = {}
+table_definition: dict = {}

{database_postgresql_local-0.1.2.1234 → database_postgresql_local-0.1.3b4665}/database_postgresql_local/src/utils.py

@@ -82,7 +82,7 @@ def generate_view_name(table_name: str) -> str:
     return f"{table_name}_view"
 
 
-def get_entity_type_id_by_table_name(table_name: str) -> int:
+def get_entity_type_by_table_name(table_name: str) -> Optional[int]:
     """Gets the entity type ID for a table."""
     # This would be implemented based on your entity type mapping
     return None
@@ -116,27 +116,27 @@ def process_update_data_dict(data_dict: dict) -> tuple:
 
 
 def process_upsert_data_dict(data_dict: dict, compare_with_or: bool = False,
-                            where_compare: str = None, params_compare: tuple = None) -> tuple:
+                            where_compare: Optional[str] = None, params_compare: Optional[tuple] = None) -> tuple:
     """Processes a dictionary for an UPSERT statement."""
     if where_compare:
         where = where_compare
         params = params_compare
     else:
         where_parts = []
-        params = []
+        params_list = []
         for key, value in data_dict.items():
             if value is None:
                 where_parts.append(f"\"{key}\" IS NULL")
             else:
                 where_parts.append(f"\"{key}\" = %s")
-                params.append(value)
+                params_list.append(value)
         connector = " OR " if compare_with_or else " AND "
         where = connector.join(where_parts)
-        params = tuple(params)
+        params = tuple(params_list)
     return where, params
 
 
-def replace_view_with_table(view_table_name: str, select_clause_value: str = None) -> str:
+def replace_view_with_table(view_table_name: str, select_clause_value: Optional[str] = None) -> str:
     """Replaces a view name with a table name."""
     if view_table_name.endswith('_view'):
         return view_table_name[:-5] + '_table'
@@ -161,7 +161,7 @@ def validate_single_clause_value(select_clause_value: str) -> None:
         raise ValueError(f"Expected a single column, got: {select_clause_value}")
 
 
-def where_skip_null_values(where: str, select_clause_value: str, skip_null_values: bool) -> str:
+def where_skip_null_values(where: Optional[str], select_clause_value: str, skip_null_values: bool) -> Optional[str]:
     """Adds a condition to skip NULL values in a WHERE clause."""
     if skip_null_values:
         null_condition = f"{select_clause_value} IS NOT NULL"
@@ -199,7 +199,7 @@ def get_table_columns(table_name: str) -> list:
 
 def group_list_by_columns(list_of_dicts: list, group_by: str) -> dict:
     """Groups a list of dictionaries by specified columns."""
-    result = {}
+    result: dict = {}
     group_by_columns = [col.strip() for col in group_by.split(',')]
     
     for item in list_of_dicts:
@@ -217,15 +217,15 @@ def group_list_by_columns(list_of_dicts: list, group_by: str) -> dict:
 def process_select_data_dict(data_dict: dict) -> tuple:
     """Processes a dictionary for a SELECT statement."""
     where_parts = []
-    params = []
+    params_list = []
     for key, value in data_dict.items():
         if value is None:
             where_parts.append(f"\"{key}\" IS NULL")
         else:
             where_parts.append(f"\"{key}\" = %s")
-            params.append(value)
+            params_list.append(value)
     where = " AND ".join(where_parts)
-    params = tuple(params)
+    params = tuple(params_list)
     return where, params
 
 
@@ -233,7 +233,7 @@ def generate_where_clause_for_ignore_duplicate(data_dict: dict, constraint_colum
     """Generates a WHERE clause for checking duplicates."""
     for columns in constraint_columns:
         where_parts = []
-        params = []
+        params_list = []
         valid = True
         for column in columns:
             if column in data_dict:
@@ -242,13 +242,13 @@ def generate_where_clause_for_ignore_duplicate(data_dict: dict, constraint_colum
                     where_parts.append(f"\"{column}\" IS NULL")
                 else:
                     where_parts.append(f"\"{column}\" = %s")
-                    params.append(value)
+                    params_list.append(value)
             else:
                 valid = False
                 break
         if valid and where_parts:
             where = " AND ".join(where_parts)
-            params = tuple(params)
+            params = tuple(params_list)
             return where, params
     return None, None
 
@@ -258,6 +258,6 @@ def fix_select_clause_value(select_clause_value: str) -> str:
     return select_clause_value
 
 
-def fix_where_clause_value(where_clause_value: str) -> str:
+def fix_where_clause_value(where_clause_value: Optional[str]) -> Optional[str]:
     """Fixes a WHERE clause value."""
     return where_clause_value

{database_postgresql_local-0.1.2.1234 → database_postgresql_local-0.1.3b4665}/database_postgresql_local.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: database-postgresql-local
-Version: 0.1.2.1234
+Version: 0.1.3b4665
 Summary: PyPI Package for Circles database-postgresql-local Python
 Home-page: https://github.com/circles-zone/database-postgresql-local-python-package
 Author: Circles
@@ -10,7 +10,7 @@ Classifier: Operating System :: OS Independent
 Description-Content-Type: text/markdown
 Requires-Dist: python-sdk-remote
 Requires-Dist: logger-local
-Requires-Dist: psycopg2
+Requires-Dist: psycopg2-binary
 Dynamic: author
 Dynamic: author-email
 Dynamic: classifier

{database_postgresql_local-0.1.2.1234 → database_postgresql_local-0.1.3b4665}/database_postgresql_local.egg-info/requires.txt

@@ -1,3 +1,3 @@
 python-sdk-remote
 logger-local
-psycopg2
+psycopg2-binary

{database_postgresql_local-0.1.2.1234 → database_postgresql_local-0.1.3b4665}/pyproject.toml

@@ -14,7 +14,7 @@ build-backend = "setuptools.build_meta"
 # TODO: Please update the name, similar to storage-local (suffix -local)
 name = "<project-name>"
 # I believe we are still using the version from setup.py and not from here until Potery will work
-version = "0.0.1" # https://pypi.org/project/<project-name> i.e. https://pypi.org/project/storage-local/
+version = "0.1.3b4665" # https://pypi.org/project/<project-name> i.e. https://pypi.org/project/storage-local/
 description = "<project-name> Python Package"
 readme = "README.md"
 authors = [

{database_postgresql_local-0.1.2.1234 → database_postgresql_local-0.1.3b4665}/setup.py

@@ -24,7 +24,7 @@ setuptools.setup(
     name=PACKAGE_NAME,
     # Increase this number every time you make a change you
     #  want to publish. After 0.0.9 switch to 0.0.10 and not 0.1.0
-    version='0.1.2.1234',  # https://pypi.org/project/database-postgresql-local/
+    version='0.1.3b4665',  # https://pypi.org/project/database-postgresql-local/
     author="Circles",
     author_email="info@circlez.ai",
     description=f"PyPI Package for Circles {PACKAGE_NAME} Python",
@@ -58,6 +58,6 @@ setuptools.setup(
         # TODO: in -remote package please use logger-remote instead.
         'logger-local',
         # TODO: In -remote package please delete this line.
-        'psycopg2'
+        'psycopg2-binary'
     ]
 )

database_postgresql_local-0.1.2.1234/README.md

@@ -1 +0,0 @@
-TODO Please update the README of the package