lukhed-basic-utils 1.6.2__tar.gz → 1.6.4__tar.gz

{lukhed_basic_utils-1.6.2 → lukhed_basic_utils-1.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lukhed_basic_utils
-Version: 1.6.2
+Version: 1.6.4
 Summary: A collection of basic utility functions
 Home-page: https://github.com/lukhed/lukhed_basic_utils
 Author: lukhed

{lukhed_basic_utils-1.6.2 → lukhed_basic_utils-1.6.4}/lukhed_basic_utils/githubCommon.py

@@ -125,7 +125,7 @@ class GithubHelper:
             i = input((f'ERROR: There is no project "{self.project}" in the config file. Would you like to go thru setup '
                    'to add a new Github key for this project name? (y/n): '))
             if i == 'y':
-                self._guided_setup()
+                self._gh_guided_setup()
             else:
                 print("Ok, exiting...")
                 quit()
@@ -133,7 +133,7 @@ class GithubHelper:
     def _prompt_for_setup(self):
         i = input("1. You do not have a valid config file to utilize github. Do you want to go thru easy setup? (y/n):")
         if i == 'y':
-            self._guided_setup()
+            self._gh_guided_setup()
         elif i == 'n':
             print("OK, to use github functions, see https://github.com/lukhed/lukhed_basic_utils for more information.")
             quit()
@@ -141,7 +141,7 @@ class GithubHelper:
             print("Did not get an expected result of 'y' or 'n'. Please reinstantiate and try again. Exiting script.")
             quit()
 
-    def _guided_setup(self):
+    def _gh_guided_setup(self):
         input(("\n2. Starting setup\n"
                "The github key you provide in this setup will be stored locally only. "
                f"After setup, you can see the config file in your specified destination {self._github_config_file}"

{lukhed_basic_utils-1.6.2 → lukhed_basic_utils-1.6.4}/lukhed_basic_utils/sqlCommon.py

@@ -4,6 +4,9 @@ from mysql.connector.connection import MySQLConnection
 import mysql.connector
 import atexit
 import json
+import psycopg2
+import atexit
+from psycopg2 import sql
 
 class SqlHelper(classCommon.LukhedAuth):
     def __init__(self, datbase_project, datbase_name, key_management='github', auth_type='basic', 
@@ -49,9 +52,9 @@ class SqlHelper(classCommon.LukhedAuth):
         self.cursor = None
         atexit.register(self.close_connection)
 
-
     ###################
     # Auth and Connection
+    
     def _auth_setup(self):
         """
         Set up authentication for the SQL database.
@@ -1249,11 +1252,934 @@ class SqlHelper(classCommon.LukhedAuth):
         self.cursor.execute(alter_query)
         self.db_connection.commit()
 
+class PostgresSqlHelper(classCommon.LukhedAuth):
+    def __init__(self, datbase_project, datbase_name, key_management='github', auth_type='basic',
+                 auth_dict=None):
+        """
+        Initializes the PostgresSqlHelper class for managing PostgreSQL database connections and operations.
+
+        This class mirrors the structure and behavior of the original MySQL-based SqlHelper but is adapted for use with 
+        PostgreSQL databases such as those hosted on Supabase. It provides support for table management, data insertion, 
+        querying, and connection handling using psycopg2.
+
+        Parameters
+        ----------
+        datbase_project : str
+            Name of the project or repository where the database is hosted. This class will use this to manage 
+            the authentication data going forward. Setup the authentication data for a project one time and then you 
+            can re-use it for all future connections to the database by utilizing the database project name.
+        datbase_name : str
+            Name of the PostgreSQL database to connect to. All queries and operations will be performed on this database. 
+            You can change the database later by using the `change_database` method.
+        key_management : str, optional
+            Options for storing your authentication data. 'local' to store your auth on your local hardware. 
+            'github' to store it in a private GitHub repository (you will need a GitHub account and GitHub token),
+            by default 'github'
+        auth_type : str, optional
+            Currently supports 'basic' auth, which is authentication by 'host', 'user', and 'password', by default 'basic'
+        auth_dict : dict, optional
+            By default, this class will walk you through providing your authentication data to be stored according 
+            to your preference via command prompts. You can also provide the necessary dictionary via this 
+            parameter to skip the setup., by default None
+        """
+
+        super().__init__(datbase_project, key_management=key_management)
+
+        self.auth_type = auth_type
+        self._auth_dict = auth_dict
+
+        self.database_project = datbase_project
+        self.database_name = datbase_name
+
+        if self._auth_data is None:
+            self._auth_setup()
+
+        self.db_connection = None
+        self.cursor = None
+        atexit.register(self.close_connection)
+
+    
+    ###################
+    # Auth and Connection
+    def _auth_setup(self):
+        if self.auth_type == 'basic':
+            if self._auth_dict is None:
+                input("Basic auth requires the following information: 'host', 'user', 'password', and 'port' "
+                    "Press enter to start inputting these values.")
+                host = input("Enter host (e.g. db.xxxxxx.supabase.co): ")
+                user = input("Enter user: ")
+                password = input("Enter password: ")
+                port = input("Enter port: ")
+
+                self._auth_data = {
+                    "host": host,
+                    "user": user,
+                    "password": password,
+                    "port": port
+                }
+
+            self.kM.force_update_key_data(self._auth_data)
+            print("Basic auth data has been set up successfully.")
+        else:
+            raise ValueError(f"Unsupported auth_type: {self.auth_type}")
+
+    def _check_connect_db(self):
+        if self.db_connection is None:
+            self.connect()
+
+    def connect(self):
+        self.db_connection = psycopg2.connect(
+            host=self._auth_data['host'],
+            user=self._auth_data['user'],
+            password=self._auth_data['password'],
+            dbname=self.database_name,
+            port=self._auth_data['port']
+        )
+        self.cursor = self.db_connection.cursor()
+
+    def test_connection(self):
+        self._check_connect_db()
+        print(f"Connected to the database {self.database_name}")
+
+    def close_connection(self):
+        if self.cursor:
+            self.cursor.close()
+        if self.db_connection:
+            self.db_connection.close()
+            print(f"Connection was closed to {self.database_name}")
+
+    def change_database(self, database_name):
+        self.close_connection()
+        self.database_name = database_name
+        print("New database is: " + self.database_name)
+
+    def update_auth_data(self, force_new_auth_dict=None):
+        if force_new_auth_dict is not None:
+            self._auth_dict = force_new_auth_dict
+        self._auth_setup()
+
+    
+    ##################
+    # Table Management
+    def get_all_tables(self):
+        self._check_connect_db()
+        query = """
+            SELECT tablename
+            FROM pg_catalog.pg_tables
+            WHERE schemaname != 'pg_catalog' AND schemaname != 'information_schema';
+        """
+        self.cursor.execute(query)
+        tables = [table[0] for table in self.cursor.fetchall()]
+        return tables
+
+    def create_table(self, table_name, *column_tuples, include_id=False):
+        self._check_connect_db()
+
+        if isinstance(column_tuples[0][0], (tuple, list)):
+            column_tuples = column_tuples[0]
+
+        if include_id:
+            id_column = ('id', 'SERIAL PRIMARY KEY')
+            column_tuples = [id_column] + list(column_tuples)
+
+        columns_str = ', '.join([f'{col_name} {col_type}' for col_name, col_type in column_tuples])
+        query = sql.SQL("CREATE TABLE {} ({})").format(
+            sql.Identifier(table_name),
+            sql.SQL(columns_str)
+        )
+
+        self.cursor.execute(query)
+        self.db_connection.commit()
+
+    def delete_table(self, table_name):
+        self._check_connect_db()
+        query = sql.SQL("DROP TABLE IF EXISTS {} CASCADE").format(sql.Identifier(table_name))
+        self.cursor.execute(query)
+        self.db_connection.commit()
+
+    def table_exists(self, table_name):
+        self._check_connect_db()
+        query = """
+            SELECT EXISTS (
+                SELECT 1
+                FROM information_schema.tables
+                WHERE table_schema = 'public' AND table_name = %s
+            );
+        """
+        self.cursor.execute(query, (table_name,))
+        return self.cursor.fetchone()[0]
+
+    def rename_table(self, old_table_name, new_table_name):
+        self._check_connect_db()
+        query = sql.SQL("ALTER TABLE {} RENAME TO {}").format(
+            sql.Identifier(old_table_name),
+            sql.Identifier(new_table_name)
+        )
+        self.cursor.execute(query)
+        self.db_connection.commit()
+
+    def reset_table(self, table_name, reset_auto_increment=True):
+        """
+        This function deletes all rows from a table and optionally resets the auto-increment (SERIAL) sequence.
+
+        Parameters
+        ----------
+        table_name : str
+            Table name you want to erase from the currently connected db
+        reset_auto_increment : bool, optional
+            If TRUE, resets auto increment of id also (assumes column is named 'id')
+        """
+        self._check_connect_db()
+
+        # Delete all rows from the table
+        query = sql.SQL("DELETE FROM {}").format(sql.Identifier(table_name))
+        self.cursor.execute(query)
+        self.db_connection.commit()
+
+        # Reset auto-increment sequence if requested
+        if reset_auto_increment:
+            sequence_name = f"{table_name}_id_seq"
+            reset_query = sql.SQL("ALTER SEQUENCE {} RESTART WITH 1").format(sql.Identifier(sequence_name))
+            self.cursor.execute(reset_query)
+            self.db_connection.commit()
+
+    def remove_rows_from_table(self, table_name, rows=1, order_column="id"):
+        """
+        Removes a number of rows from a table by ordering with a specified column.
+
+        Parameters
+        ----------
+        table_name : str
+            Name of the table
+        rows : int, optional
+            Number of rows to remove (default is 1)
+        order_column : str, optional
+            Column by which to order the table for row removal (default is "id")
+        """
+        self._check_connect_db()
+
+        query = sql.SQL(
+            "DELETE FROM {} WHERE ctid IN (SELECT ctid FROM {} ORDER BY {} DESC LIMIT %s)"
+        ).format(
+            sql.Identifier(table_name),
+            sql.Identifier(table_name),
+            sql.Identifier(order_column)
+        )
+        self.cursor.execute(query, (rows,))
+        self.db_connection.commit()
+
+
+    ########################
+    # Table Data Management: Data Checks and Queries
+    def display_table_in_console(self, table_name, max_rows=20, min_column_width=15):
+        """
+        Display a formatted table in the console with proper alignment and borders.
+
+        Parameters
+        ----------
+        table_name : str
+            Name of the table to display
+        max_rows : int, optional
+            Maximum number of rows to display (default is 20)
+        min_column_width : int, optional
+            Minimum width for each column (default is 15)
+
+        Returns
+        -------
+        None
+        """
+        self._check_connect_db()
+        select_query = f'SELECT * FROM "{table_name}"'
+        self.cursor.execute(select_query)
+
+        columns = [desc[0] for desc in self.cursor.description]
+        data = self.cursor.fetchmany(max_rows) if max_rows else self.cursor.fetchall()
+
+        col_widths = []
+        for i, col in enumerate(columns):
+            content_width = max(
+                max(len(str(row[i])) for row in data) if data else 0,
+                len(col)
+            )
+            col_widths.append(max(content_width + 2, min_column_width))
+
+        separator = '+' + '+'.join('-' * width for width in col_widths) + '+'
+
+        print(f"\nTable: {table_name}")
+        print(separator)
+        print('|' + '|'.join(
+            f"{col:^{width}}" for col, width in zip(columns, col_widths)
+        ) + '|')
+        print(separator)
+
+        for row in data:
+            print('|' + '|'.join(
+                f"{str(cell):^{width}}" for cell, width in zip(row, col_widths)
+            ) + '|')
+
+        print(separator)
+        if max_rows and len(data) == max_rows:
+            print(f"Note: Showing first {max_rows} rows only.")
+
+    def get_table_as_list(self, table_name, max_rows=None):
+        self._check_connect_db()
+        select_query = f'SELECT * FROM "{table_name}"'
+        self.cursor.execute(select_query)
+
+        columns = [desc[0] for desc in self.cursor.description]
+        data = self.cursor.fetchmany(max_rows) if max_rows else self.cursor.fetchall()
+
+        return [columns] + [list(row) for row in data]
+
+    def get_last_x_entries(self, table_name, x):
+        """
+        This function assumes the table has an 'id' column to order by.
+
+        Parameters
+        ----------
+        table_name : str
+            Name of the table
+        x : int
+            Number of last entries to retrieve
+
+        Returns
+        -------
+        list
+            List of rows including column headers
+        """
+        self._check_connect_db()
+        select_query = f'SELECT * FROM "{table_name}" ORDER BY id DESC LIMIT %s'
+        self.cursor.execute(select_query, (x,))
+
+        columns = [desc[0] for desc in self.cursor.description]
+        data = self.cursor.fetchall()
+        return [columns] + [list(row) for row in data]
 
+    def query_table_by_columns(self, table_name, *condition_tuples):
+        """
+        Query the table by specified columns and conditions.
 
+        Parameters
+        ----------
+        table_name : str
+            Name of the table to query
+        condition_tuples : tuple(s) or list of tuples
+            Conditions for the query, specified as tuples of column-value pairs
 
+        Returns
+        -------
+        list
+            A list of rows matching the query conditions
+        """
+        self._check_connect_db()
 
+        if isinstance(condition_tuples[0][0], (tuple, list)):
+            conditions_list = [
+                " AND ".join([f"{col} = %s" for col, _ in group]) for group in condition_tuples
+            ]
+            values = [val for group in condition_tuples for _, val in group]
+        else:
+            conditions_list = [" AND ".join([f"{col} = %s" for col, _ in condition_tuples])]
+            values = [val for _, val in condition_tuples]
 
+        conditions_sql = " OR ".join(conditions_list)
+        query = f'SELECT * FROM "{table_name}" WHERE {conditions_sql};'
 
+        self.cursor.execute(query, values)
+        return [list(row) for row in self.cursor.fetchall()]
 
+    def query_by_month_day(self, table_name, date_column, date_string):
+        """
+        Query records where the date matches the month and day.
 
+        Parameters
+        ----------
+        table_name : str
+            Name of the table to query
+        date_column : str
+            The column name with date
+        date_string : str
+            Target date (e.g., '2024-01-15')
+
+        Returns
+        -------
+        list
+            A list of rows matching the query conditions
+        """
+        self._check_connect_db()
+
+        query = f'''
+            SELECT *
+            FROM "{table_name}"
+            WHERE EXTRACT(MONTH FROM {date_column}) = EXTRACT(MONTH FROM %s::date)
+            AND EXTRACT(DAY FROM {date_column}) = EXTRACT(DAY FROM %s::date)
+        '''
+        self.cursor.execute(query, (date_string, date_string))
+        return [list(row) for row in self.cursor.fetchall()]
+
+    def get_columns_with_null_values(self, table_name, *lookup_condition_tuples):
+        """
+        Get columns with null values in the specified row.
+
+        Parameters
+        ----------
+        table_name : str
+            Name of the table
+        lookup_condition_tuples : tuple(s) or list of tuples
+            Conditions to identify the row
+
+        Returns
+        -------
+        list of str
+            Column names with NULL values in the row
+        """
+        self._check_connect_db()
+
+        if isinstance(lookup_condition_tuples[0][0], (tuple, list)):
+            conditions = [f"{col} = %s" for col, _ in lookup_condition_tuples[0]]
+            values = [val for _, val in lookup_condition_tuples[0]]
+        else:
+            conditions = [f"{col} = %s" for col, _ in lookup_condition_tuples]
+            values = [val for _, val in lookup_condition_tuples]
+
+        query = f'SELECT * FROM "{table_name}" WHERE {" AND ".join(conditions)} LIMIT 1'
+        self.cursor.execute(query, values)
+        row = self.cursor.fetchone()
+
+        if row is None:
+            return []
+
+        columns = [desc[0] for desc in self.cursor.description]
+        return [col for col, val in zip(columns, row) if val is None]
+
+    def is_value_null(self, table_name, to_check_column, *lookup_condition_tuples):
+        """
+        Check if a value is NULL in the specified table and column.
+
+        Parameters
+        ----------
+        table_name : str
+            Table to check
+        to_check_column : str
+            Column to evaluate
+        lookup_condition_tuples : tuple(s) or list of tuples
+            Conditions to identify the row
+
+        Returns
+        -------
+        bool
+            True if NULL, False otherwise
+        """
+        result = self.get_single_value_from_table(table_name, to_check_column, *lookup_condition_tuples)
+        return result is None
+
+    def check_if_data_exists(self, table_name, columns, values):
+        """
+        Check if a specific row exists based on multiple column values.
+
+        Parameters
+        ----------
+        table_name : str
+            Table name
+        columns : list of str
+            Columns to match
+        values : list
+            Values to match against columns
+
+        Returns
+        -------
+        bool
+            True if a match exists, False otherwise
+        """
+        self._check_connect_db()
+
+        conditions = ' AND '.join([f"{col} = %s" for col in columns])
+        query = f'SELECT COUNT(*) FROM "{table_name}" WHERE {conditions}'
+        self.cursor.execute(query, values)
+        return self.cursor.fetchone()[0] > 0
+
+    def check_if_value_exists_in_column(self, table_name, column, value_to_check):
+        """
+        Check if a value exists in a specific column of a table.
+
+        Parameters
+        ----------
+        table_name : str
+            Table to search
+        column : str
+            Column name
+        value_to_check : any
+            Value to search for
+
+        Returns
+        -------
+        bool
+            True if the value exists, False otherwise
+        """
+        self._check_connect_db()
+
+        query = f'SELECT COUNT(*) FROM "{table_name}" WHERE {column} = %s'
+        self.cursor.execute(query, (value_to_check,))
+        return self.cursor.fetchone()[0] > 0
+
+    #######################
+    # Table Data Management: Inserts and Updates
+    def insert_data(self, table_name, columns, values, check_for_unique=False):
+        """
+        Inserts a row into a PostgreSQL table. Optionally checks for uniqueness.
+
+        Parameters
+        ----------
+        table_name : str
+        columns : list of str
+        values : list
+        check_for_unique : bool
+
+        Returns
+        -------
+        bool
+        """
+        add_data = True
+        if check_for_unique:
+            add_data = not self.check_if_data_exists(table_name, columns, values)
+
+        if add_data:
+            self._check_connect_db()
+            query = sql.SQL("INSERT INTO {} ({}) VALUES ({})").format(
+                sql.Identifier(table_name),
+                sql.SQL(', ').join(map(sql.Identifier, columns)),
+                sql.SQL(', ').join(sql.Placeholder() * len(values))
+            )
+            self.cursor.execute(query, values)
+            self.db_connection.commit()
+            return True
+        else:
+            print("Data already exists in the table matching the information you are trying to add.")
+            return False
+
+    def insert_data_as_table(self, table_name, table_columns, table_rows_list_of_list):
+        """
+        Insert multiple rows into a PostgreSQL table.
+
+        Parameters
+        ----------
+        table_name : str
+        table_columns : list of str
+        table_rows_list_of_list : list of list
+        """
+        self._check_connect_db()
+
+        query = sql.SQL("INSERT INTO {} ({}) VALUES ({})").format(
+            sql.Identifier(table_name),
+            sql.SQL(', ').join(map(sql.Identifier, table_columns)),
+            sql.SQL(', ').join(sql.Placeholder() * len(table_columns))
+        )
+
+        try:
+            for row_values in table_rows_list_of_list:
+                self.cursor.execute(query, row_values)
+            self.db_connection.commit()
+        except Exception as e:
+            self.db_connection.rollback()
+            print(f"An error occurred: {e}")
+
+    def update_single_value_in_table(self, table_name, column_to_update, new_value, *lookup_condition_tuples):
+        """
+        Update a single column's value in a specific row.
+
+        Parameters
+        ----------
+        table_name : str
+        column_to_update : str
+        new_value : any
+        lookup_condition_tuples : tuple(s)
+        """
+        self._check_connect_db()
+
+        if isinstance(lookup_condition_tuples[0][0], (tuple, list)):
+            conditions = [f"{col} = %s" for col, _ in lookup_condition_tuples[0]]
+            values = [val for _, val in lookup_condition_tuples[0]]
+        else:
+            conditions = [f"{col} = %s" for col, _ in lookup_condition_tuples]
+            values = [val for _, val in lookup_condition_tuples]
+
+        where_clause = " AND ".join(conditions)
+        query = sql.SQL("UPDATE {} SET {} = %s WHERE " + where_clause).format(
+            sql.Identifier(table_name),
+            sql.Identifier(column_to_update)
+        )
+        self.cursor.execute(query, [new_value] + values)
+        self.db_connection.commit()
+
+    def update_multiple_values_in_table(self, table_name, columns_to_update_list, values_to_update_list, *lookup_condition_tuples):
+        """
+        Update multiple columns in a single row using WHERE conditions.
+
+        Parameters
+        ----------
+        table_name : str
+        columns_to_update_list : list of str
+        values_to_update_list : list
+        lookup_condition_tuples : tuple(s)
+        """
+        self._check_connect_db()
+
+        if isinstance(lookup_condition_tuples[0][0], (tuple, list)):
+            conditions = [f"{col} = %s" for col, _ in lookup_condition_tuples[0]]
+            values = [val for _, val in lookup_condition_tuples[0]]
+        else:
+            conditions = [f"{col} = %s" for col, _ in lookup_condition_tuples]
+            values = [val for _, val in lookup_condition_tuples]
+
+        set_clause = ', '.join([f"{col} = %s" for col in columns_to_update_list])
+        where_clause = " AND ".join(conditions)
+
+        query = sql.SQL(f"UPDATE {{}} SET {set_clause} WHERE {where_clause}").format(
+            sql.Identifier(table_name)
+        )
+        self.cursor.execute(query, values_to_update_list + values)
+        self.db_connection.commit()
+
+
+    #######################
+    # Table Data Management: Columns
+    def get_columns_in_table(self, table_name):
+        """
+        Get the list of column names in the specified PostgreSQL table.
+
+        Parameters
+        ----------
+        table_name : str
+
+        Returns
+        -------
+        list of str
+            Column names
+        """
+        self._check_connect_db()
+        query = """
+            SELECT column_name
+            FROM information_schema.columns
+            WHERE table_schema = 'public' AND table_name = %s;
+        """
+        self.cursor.execute(query, (table_name,))
+        return [row[0] for row in self.cursor.fetchall()]
+    
+    def add_column_to_table(self, table_name, column_name, column_type, after_column=None):
+        """
+        Add a column to the specified PostgreSQL table.
+
+        Parameters
+        ----------
+        table_name : str
+        column_name : str
+        column_type : str
+        after_column : str, optional (ignored in PostgreSQL)
+        """
+        self._check_connect_db()
+
+        query = sql.SQL("ALTER TABLE {} ADD COLUMN {} {}").format(
+            sql.Identifier(table_name),
+            sql.Identifier(column_name),
+            sql.SQL(column_type)
+        )
+        self.cursor.execute(query)
+        self.db_connection.commit()
+
+    def rename_column(self, table_name, old_column_name, new_column_name):
+        """
+        Rename a column in a PostgreSQL table.
+
+        Parameters
+        ----------
+        table_name : str
+        old_column_name : str
+        new_column_name : str
+        """
+        self._check_connect_db()
+        query = sql.SQL("ALTER TABLE {} RENAME COLUMN {} TO {}").format(
+            sql.Identifier(table_name),
+            sql.Identifier(old_column_name),
+            sql.Identifier(new_column_name)
+        )
+        self.cursor.execute(query)
+        self.db_connection.commit()
+
+    def change_column_type(self, table_name, column_name, new_type):
+        """
+        Change the data type of a column in PostgreSQL.
+
+        Parameters
+        ----------
+        table_name : str
+        column_name : str
+        new_type : str
+        """
+        self._check_connect_db()
+        query = sql.SQL("ALTER TABLE {} ALTER COLUMN {} TYPE {}").format(
+            sql.Identifier(table_name),
+            sql.Identifier(column_name),
+            sql.SQL(new_type)
+        )
+        self.cursor.execute(query)
+        self.db_connection.commit()
+
+    def change_column_charset(self, table_name, column_name, new_charset, new_collation):
+        """
+        Change the collation of a column in PostgreSQL (character sets are cluster-level).
+
+        Parameters
+        ----------
+        table_name : str
+        column_name : str
+        new_charset : str (ignored – PostgreSQL uses UTF-8)
+        new_collation : str (PostgreSQL collation name)
+        """
+        self._check_connect_db()
+        query = sql.SQL("ALTER TABLE {} ALTER COLUMN {} SET COLLATION {}").format(
+            sql.Identifier(table_name),
+            sql.Identifier(column_name),
+            sql.Identifier(new_collation)
+        )
+        self.cursor.execute(query)
+        self.db_connection.commit()
+
+    def delete_column(self, table_name, column_name):
+        """
+        Delete a column from a PostgreSQL table.
+        """
+        self._check_connect_db()
+        query = sql.SQL("ALTER TABLE {} DROP COLUMN {}").format(
+            sql.Identifier(table_name),
+            sql.Identifier(column_name)
+        )
+        self.cursor.execute(query)
+        self.db_connection.commit()
+
+    def get_column_data_as_list(self, table_name, column_name):
+        """
+        Retrieve data from a column as a list.
+        """
+        self._check_connect_db()
+        query = sql.SQL("SELECT {} FROM {}").format(
+            sql.Identifier(column_name),
+            sql.Identifier(table_name)
+        )
+        self.cursor.execute(query)
+        return [row[0] for row in self.cursor.fetchall()]
+
+    def initialize_values_in_column_to_provided_value(self, table, column_name, value):
+        """
+        Initialize all values in a column to the provided value.
+        """
+        self._check_connect_db()
+        query = sql.SQL("UPDATE {} SET {} = %s").format(
+            sql.Identifier(table),
+            sql.Identifier(column_name)
+        )
+        self.cursor.execute(query, (value,))
+        self.db_connection.commit()
+
+    def append_value_to_column(self, table_name, column_to_append, value_to_append, *lookup_condition_tuples):
+        """
+        Append a value to a JSONB array in a PostgreSQL column.
+        """
+        self._check_connect_db()
+
+        if isinstance(lookup_condition_tuples[0][0], (tuple, list)):
+            conditions = [f"{col} = %s" for col, _ in lookup_condition_tuples[0]]
+            values = [val for _, val in lookup_condition_tuples[0]]
+        else:
+            conditions = [f"{col} = %s" for col, _ in lookup_condition_tuples]
+            values = [val for _, val in lookup_condition_tuples]
+
+        condition_sql = " AND ".join(conditions)
+        query = f"""
+            UPDATE {table_name}
+            SET {column_to_append} = COALESCE({column_to_append}, '[]'::jsonb) || to_jsonb(%s::jsonb)
+            WHERE {condition_sql}
+        """
+        self.cursor.execute(query, [json.dumps(value_to_append)] + values)
+        self.db_connection.commit()
+
+    def append_values_to_columns(self, table_name, columns_to_append_to, values_to_append, *lookup_condition_tuples):
+        """
+        Append values to multiple JSONB columns in PostgreSQL.
+        """
+        self._check_connect_db()
+
+        if isinstance(lookup_condition_tuples[0][0], (tuple, list)):
+            conditions = [f"{col} = %s" for col, _ in lookup_condition_tuples[0]]
+            values = [val for _, val in lookup_condition_tuples[0]]
+        else:
+            conditions = [f"{col} = %s" for col, _ in lookup_condition_tuples]
+            values = [val for _, val in lookup_condition_tuples]
+
+        condition_sql = " AND ".join(conditions)
+        update_parts = []
+        value_placeholders = []
+
+        for col, val in zip(columns_to_append_to, values_to_append):
+            update_parts.append(
+                f"{col} = COALESCE({col}, '[]'::jsonb) || to_jsonb(%s::jsonb)"
+            )
+            value_placeholders.append(json.dumps(val))
+
+        query = f"""
+            UPDATE {table_name}
+            SET {', '.join(update_parts)}
+            WHERE {condition_sql}
+        """
+        self.cursor.execute(query, value_placeholders + values)
+        self.db_connection.commit()
+
+    def append_values_to_columns_concat(self, table_name, columns_to_append_to, values_to_append, *lookup_condition_tuples):
+        """
+        Append values to multiple columns using string concatenation.
+        """
+        self._check_connect_db()
+
+        if isinstance(lookup_condition_tuples[0][0], (tuple, list)):
+            conditions = [f"{col} = %s" for col, _ in lookup_condition_tuples[0]]
+            values = [val for _, val in lookup_condition_tuples[0]]
+        else:
+            conditions = [f"{col} = %s" for col, _ in lookup_condition_tuples]
+            values = [val for _, val in lookup_condition_tuples]
+
+        condition_sql = " AND ".join(conditions)
+
+        for col, val in zip(columns_to_append_to, values_to_append):
+            query = f"""
+                UPDATE {table_name}
+                SET {col} = COALESCE({col}, '') || ', {json.dumps(val)}'
+                WHERE {condition_sql}
+            """
+            self.cursor.execute(query, values)
+            self.db_connection.commit()
+
+    #######################
+    # Table Data Management: Rows
+    def get_total_rows(self, table_name):
+        """
+        Get the total number of rows in the specified table.
+        """
+        self._check_connect_db()
+        query = sql.SQL("SELECT COUNT(*) FROM {}").format(sql.Identifier(table_name))
+        self.cursor.execute(query)
+        return self.cursor.fetchone()[0]
+
+    def delete_first_rows(self, table_name, x):
+        """
+        Delete the first x rows from the specified table.
+        NOTE: Requires a primary key or ordering column for deterministic behavior.
+        """
+        self._check_connect_db()
+        # Replace 'id' with your table's primary key if needed
+        query = sql.SQL("""
+            DELETE FROM {table}
+            WHERE ctid IN (
+                SELECT ctid FROM {table}
+                ORDER BY ctid
+                LIMIT %s
+            )
+        """).format(table=sql.Identifier(table_name))
+        self.cursor.execute(query, (x,))
+        self.db_connection.commit()
+
+    def get_single_value_from_table(self, table_name, column_to_retrieve, *lookup_condition_tuples):
+        """
+        Retrieve a single value from the specified table.
+        """
+        self._check_connect_db()
+
+        if isinstance(lookup_condition_tuples[0][0], (tuple, list)):
+            conditions = [f"{col} = %s" for col, _ in lookup_condition_tuples[0]]
+            values = [val for _, val in lookup_condition_tuples[0]]
+        else:
+            conditions = [f"{col} = %s" for col, _ in lookup_condition_tuples]
+            values = [val for _, val in lookup_condition_tuples]
+
+        condition_sql = " AND ".join(conditions)
+        query = sql.SQL("SELECT {} FROM {} WHERE {} LIMIT 1").format(
+            sql.Identifier(column_to_retrieve),
+            sql.Identifier(table_name),
+            sql.SQL(condition_sql)
+        )
+
+        self.cursor.execute(query, values)
+        result = self.cursor.fetchone()
+
+        return result[0] if result and len(result) == 1 else result
+
+    def bulk_update_rows(self, table_name, columns_to_update, rows_to_update):
+        """
+        Perform a bulk update of rows in the specified table.
+        This method assumes the first column in columns_to_update is the unique key.
+        """
+        self._check_connect_db()
+
+        key_column = columns_to_update[0]
+        set_columns = columns_to_update[1:]
+
+        cases = {col: [] for col in set_columns}
+        ids = []
+
+        for row in rows_to_update:
+            row_dict = dict(zip(columns_to_update, row))
+            key = row_dict[key_column]
+            ids.append(key)
+            for col in set_columns:
+                cases[col].append((key, row_dict[col]))
+
+        set_clauses = []
+        values = []
+
+        for col, case_list in cases.items():
+            case_sql = f"{col} = CASE {key_column} " + \
+                ' '.join([f"WHEN %s THEN %s" for _ in case_list]) + " ELSE {col} END"
+            set_clauses.append(case_sql)
+            for pair in case_list:
+                values.extend(pair)
+
+        query = f"""
+            UPDATE {table_name}
+            SET {', '.join(set_clauses)}
+            WHERE {key_column} IN ({', '.join(['%s'] * len(ids))});
+        """
+        values.extend(ids)
+        self.cursor.execute(query, values)
+        self.db_connection.commit()
+
+
+    ###################
+    # General Query Execution
+    def execute_query(self, query, params=None):
+        """
+        Execute a SQL query with optional parameters.
+
+        Parameters
+        ----------
+        query : str
+            The SQL query to be executed
+        params : tuple or list, optional
+            Parameters to be passed to the query
+
+        Returns
+        -------
+        cursor
+            For SELECT queries, returns cursor for fetching results
+        None
+            For other queries
+        """
+        self._check_connect_db()
+        
+        if params is None:
+            self.cursor.execute(query)
+        else:
+            self.cursor.execute(query, params)
+
+        if query.strip().upper().startswith('SELECT'):
+            return self.cursor
+
+        self.db_connection.commit()
+        return None

{lukhed_basic_utils-1.6.2 → lukhed_basic_utils-1.6.4}/lukhed_basic_utils.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lukhed-basic-utils
-Version: 1.6.2
+Version: 1.6.4
 Summary: A collection of basic utility functions
 Home-page: https://github.com/lukhed/lukhed_basic_utils
 Author: lukhed

{lukhed_basic_utils-1.6.2 → lukhed_basic_utils-1.6.4}/lukhed_basic_utils.egg-info/requires.txt

@@ -9,3 +9,4 @@ numpy>=2.2.4
 pandas>=2.2.3
 scipy>=1.15.2
 mysql-connector-python>=8.0.0
+psycopg2-binary>=2.9.10

{lukhed_basic_utils-1.6.2 → lukhed_basic_utils-1.6.4}/setup.py

@@ -2,7 +2,7 @@ from setuptools import setup, find_packages
 
 setup(
     name="lukhed_basic_utils",
-    version="1.6.2",
+    version="1.6.4",
     description="A collection of basic utility functions",
     long_description=open("README.md").read(),
     long_description_content_type="text/markdown",
@@ -21,12 +21,13 @@ setup(
         "requests>=2.32.3",
         "beautifulsoup4>=4.12.3",
         "fake-useragent>=2.0.3",
-        "tzdata>=2023.3",
+        "tzdata>=2023.3",   
         "PyGithub>= 2.5.0",
         "matplotlib>=3.10.1",
         "numpy>=2.2.4",
         "pandas>=2.2.3",
         "scipy>=1.15.2",
-        "mysql-connector-python>=8.0.0"
+        "mysql-connector-python>=8.0.0",
+        "psycopg2-binary>=2.9.10"
     ],
 )