database-postgresql-local 0.1.0__py3-none-any.whl

database_postgresql_local/__init__.py

@@ -0,0 +1 @@
+# Database PostgreSQL Local Package

database_postgresql_local/connector.py

@@ -0,0 +1,156 @@
+from __future__ import annotations  # Required for type hinting in class methods
+
+from collections import defaultdict
+from os.path import expanduser
+from typing import Optional
+
+import psycopg2
+from psycopg2 import pool
+from logger_local.MetaLogger import MetaLogger
+
+from .constants_src import LOGGER_CONNECTOR_CODE_OBJECT
+from .cursor import Cursor
+from .utils import (get_sql_hostname, get_sql_password, get_sql_username, get_sql_port)
+
+connections_pool = defaultdict(dict)
+home = expanduser('~')
+
+
+class Connector(metaclass=MetaLogger, object=LOGGER_CONNECTOR_CODE_OBJECT):
+    @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]:
+            connections_pool[user].pop(schema_name)
+
+        if connections_pool[user].get(schema_name):
+            # Check if connection is still valid
+            connector = None
+            try:
+                # Test if connection is still alive
+                connections_pool[user][schema_name].connection.cursor().execute("SELECT 1")
+                connector = connections_pool[user][schema_name]
+            except (Exception, psycopg2.DatabaseError):
+                # Reconnect if connection is closed
+                try:
+                    connections_pool[user][schema_name].connection.close()
+                except:
+                    pass
+                connections_pool[user].pop(schema_name, None)
+                connector = Connector(schema_name)
+                connections_pool[user][schema_name] = connector
+        else:
+            connector = Connector(schema_name)
+            connections_pool[user][schema_name] = connector
+
+        return connector
+
+    def __init__(self, schema_name: str, *,
+                 host: str = get_sql_hostname(),
+                 user: str = get_sql_username(),
+                 password: str = get_sql_password(),
+                 port: str = get_sql_port()) -> None:
+        self.host = host
+        self.schema = schema_name
+        self.user = user
+        self.password = password
+        self.port = port
+        
+        # Checking host suffix
+        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._connect_to_db()
+        connections_pool[user][schema_name] = self
+
+    def reconnect(self) -> None:
+        # Called when the connection is lost
+        self._connect_to_db()
+        self._cursor = self.cursor(close_previous=True)
+        self.set_schema(self.schema)
+
+    def _connect_to_db(self):
+        try:
+            # PostgreSQL uses a database parameter instead of schema
+            # We'll connect to the default database (usually 'postgres') and then set the schema
+            self.connection = psycopg2.connect(
+                host=self.host,
+                user=self.user,
+                password=self.password,
+                port=self.port,
+                dbname='postgres'  # Connect to default database
+            )
+            self.connection.autocommit = False  # Explicit transaction control
+            self.logger.info(f"Connected to the database: {self.database_info()}")
+            self._cursor = self.connection.cursor()
+            self.set_schema(self.schema)
+        except Exception as e:
+            self.logger.error(f"Failed to connect to PostgreSQL: {e}")
+            raise
+
+    def database_info(self) -> str:
+        database_info_str = f"host={self.host}, user={self.user}, schema={self.schema}, port={self.port}"
+        return database_info_str
+
+    def close(self) -> None:
+        try:
+            if self._cursor:
+                self._cursor.close()
+                self.logger.info(f"Cursor closed successfully for schema: {self.schema}")
+        except Exception as exception:
+            self.logger.error(object={"exception": exception})
+        connections_pool[self.user].pop(self.schema, None)
+        if self.connection:
+            try:
+                self.connection.close()
+                self.logger.info("Connection closed successfully.")
+            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:
+        # 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())
+        return cursor_instance
+
+    def commit(self) -> None:
+        self.connection.commit()
+
+    def set_schema(self, new_schema: Optional[str]) -> None:
+        if not new_schema:
+            return
+        if self.schema == new_schema:
+            return
+
+        if self._cursor and self.connection:
+            try:
+                # First check if schema exists
+                self._cursor.execute(f"SELECT schema_name FROM information_schema.schemata WHERE schema_name = %s", (new_schema,))
+                if not self._cursor.fetchone():
+                    # Create schema if it doesn't exist
+                    self._cursor.execute(f'CREATE SCHEMA IF NOT EXISTS "{new_schema}"')
+                    self.connection.commit()
+                
+                # Set search path to use the schema
+                self._cursor.execute(f'SET search_path TO "{new_schema}", public')
+                connections_pool[self.user][new_schema] = self
+                connections_pool[self.user].pop(self.schema, None)
+                self.schema = new_schema
+                self.logger.info(f"Switched to schema: {new_schema}")
+            except Exception as e:
+                self.logger.error(f"Error setting schema: {e}")
+                raise
+        else:
+            raise Exception(
+                "Connection is not established. The database will be used on the next connect.")
+
+    def rollback(self):
+        self.connection.rollback()
+
+    def start_transaction(self):
+        # PostgreSQL doesn't have an explicit start_transaction method
+        # Transactions begin automatically when you execute a query
+        pass

database_postgresql_local/constants_src.py

@@ -0,0 +1,36 @@
+from enum import Enum
+
+from logger_local.LoggerComponentEnum import LoggerComponentEnum
+
+
+# TODO Move everything related to sync to separate directory called
+#  sync_data_source (preferable with it's own src and tests directories)
+class UpdateStatus(Enum):
+    UPDATE_DATA_SOURCE = -1
+    DONT_UPDATE = 0
+    UPDATE_CIRCLEZ = 1  # TODO Don't use CIRCLEZ
+
+
+# connector / cursor
+DATABASE_POSTGRESQL_PYTHON_PACKAGE_COMPONENT_ID = 113
+DATABASE_POSTGRESQL_PYTHON_PACKAGE_COMPONENT_NAME = 'database_postgresql_local\\connector'
+CONNECTOR_DEVELOPER_EMAIL = 'idan.a@circ.zone'
+LOGGER_CONNECTOR_CODE_OBJECT = {
+    'component_id': DATABASE_POSTGRESQL_PYTHON_PACKAGE_COMPONENT_ID,
+    'component_name': DATABASE_POSTGRESQL_PYTHON_PACKAGE_COMPONENT_NAME,
+    'component_category': LoggerComponentEnum.ComponentCategory.Code.value,
+    'developer_email': CONNECTOR_DEVELOPER_EMAIL
+}
+
+# generic_crud
+DATABASE_POSTGRESQL_PYTHON_GENERIC_CRUD_COMPONENT_ID = 207
+DATABASE_POSTGRESQL_PYTHON_GENERIC_CRUD_COMPONENT_NAME = 'database_postgresql_local\\generic_crud_postgresql'
+GENERIC_CRUD_DEVELOPER_EMAIL = 'akiva.s@circ.zone'
+CRUD_POSTGRESQL_CODE_LOGGER_OBJECT = {
+    'component_id': DATABASE_POSTGRESQL_PYTHON_GENERIC_CRUD_COMPONENT_ID,
+    'component_name': DATABASE_POSTGRESQL_PYTHON_GENERIC_CRUD_COMPONENT_NAME,
+    'component_category': LoggerComponentEnum.ComponentCategory.Code.value,
+    'developer_email': GENERIC_CRUD_DEVELOPER_EMAIL
+}
+CRUD_POSTGRESQL_TEST_LOGGER_OBJECT = CRUD_POSTGRESQL_CODE_LOGGER_OBJECT.copy()
+CRUD_POSTGRESQL_TEST_LOGGER_OBJECT['component_category'] = LoggerComponentEnum.ComponentCategory.Unit_Test.value

database_postgresql_local/cursor.py

@@ -0,0 +1,142 @@
+from typing import Any
+
+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__
+
+
+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):
+    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:
+        # PostgreSQL doesn't support the multi parameter
+        # Convert MySQL-style backtick quotes to PostgreSQL double quotes
+        sql_statement = sql_statement.replace('`', '"')
+        
+        if sql_parameters:
+            # PostgreSQL uses %s for all parameter types
+            formatted_sql = sql_statement
+            sql_parameters_str = ", ".join(str(param) for param in sql_parameters)
+        else:
+            formatted_sql = sql_statement
+            sql_parameters_str = "None"
+            
+        self.logger.info(object={
+            "formatted_sql": formatted_sql.replace("\n", " "),
+            "sql_parameters": sql_parameters_str,
+            "sql_statement": sql_statement.replace("\n", " ")
+        })
+        
+        try:
+            self.cursor.execute(sql_statement, sql_parameters)
+        except Exception as e:
+            self.logger.error(f"Error executing SQL: {e}")
+            raise
+
+    def executemany(self, sql_statement: str, sql_parameters: tuple | list = None) -> None:
+        try:
+            # Convert MySQL-style backtick quotes to PostgreSQL double quotes
+            sql_statement = sql_statement.replace('`', '"')
+            
+            if sql_parameters:
+                sql_parameters_str = str(sql_parameters)
+                formatted_sql = sql_statement
+            else:
+                formatted_sql = sql_statement
+                sql_parameters_str = "None"
+                
+            self.logger.info(object={
+                "formatted_sql": formatted_sql.replace("\n", " "),
+                "sql_parameters": sql_parameters_str,
+                "sql_statement": sql_statement.replace("\n", " ")
+            })
+            
+            self.cursor.executemany(sql_statement, sql_parameters)
+        except Exception as e:
+            self.logger.warning('Unable to execute statement', object={
+                "sql_statement": sql_statement,
+                "sql_parameters": sql_parameters,
+                "error": str(e)
+            })
+            raise
+
+    def fetchall(self) -> Any:
+        result = self.cursor.fetchall()
+        return result
+
+    def fetchmany(self, size: int) -> Any:
+        result = self.cursor.fetchmany(size)
+        return result
+
+    def fetchone(self) -> Any:
+        result = self.cursor.fetchone()
+        return result
+
+    def description(self) -> list[tuple]:
+        """Returns description of columns in a result
+
+        This property returns a list of tuples describing the columns
+        in a result set. A tuple is described as follows::
+
+                (column_name,
+                 type,
+                 None,
+                 None,
+                 None,
+                 None,
+                 null_ok)
+        """
+        result = self.cursor.description
+        return result
+
+    def column_names(self) -> tuple:
+        """Returns the column names from the last query"""
+        if self.cursor.description:
+            return tuple(desc[0] for desc in self.cursor.description)
+        return tuple()
+
+    def lastrowid(self) -> int | None:
+        """Returns the value generated for an AUTO_INCREMENT column by the previous INSERT or UPDATE statement."""
+        # PostgreSQL doesn't have a direct lastrowid property
+        # We need to use RETURNING clause in the SQL or currval() function
+        # 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]
+            return result
+        except Exception as e:
+            self.logger.warning(f"Error getting lastrowid: {e}")
+            return None
+
+    def get_affected_row_count(self) -> int:
+        """Returns the number of rows produced or affected"""
+        result = self.cursor.rowcount
+        return result
+
+    def get_last_executed_statement(self) -> str:
+        # PostgreSQL cursor doesn't store the last executed statement
+        # We would need to track this ourselves
+        return "Statement not available"
+
+    def close(self) -> None:
+        if self.__is_closed:
+            self.logger.warning('Cursor is already closed')
+        try:
+            self.cursor.close()
+            self.__is_closed = True
+        except Exception as exception:
+            self.logger.error('Unable to close cursor', object={"exception": exception})
+
+    def is_closed(self) -> bool:
+        result = self.__is_closed
+        return result