ccfx 0.1.0__py3-none-any.whl

ccfx/excel.py

@@ -0,0 +1,143 @@
+#!/bin/python3
+
+'''
+a module to easily create microsoft excel documents from python
+
+Author  : Celray James CHAWANDA
+Email   : celray.chawanda@outlook.com
+Licence : MIT 2023
+Repo    : https://github.com/celray
+
+Date    : 2023-07-20
+'''
+
+# imports
+
+import os
+import platform
+import xml.etree.ElementTree as ET
+import xlsxwriter
+from xlsxwriter.utility import xl_rowcol_to_cell
+
+# classes
+class excel:
+    def __init__(self, path):
+        self.path = path
+        self.sheet_names = {}
+        self.book = None
+        self.chart_names = []
+        self.date_format = None
+
+    def create(self):
+        self.create_path(os.path.dirname(self.path))
+        self.book = xlsxwriter.Workbook(self.path)
+
+    def addSheet(self, sheet_name):
+        if self.book is None:
+            self.create()
+        self.sheet_names[sheet_name] = self.book.add_worksheet(sheet_name)
+
+    def setDateFormat(self, format_string='dd/mm/yyyy'):
+        self.date_format = self.book.add_format({'num_format': format_string})
+
+    def writeDate(self, sheet_name, row, column, datetime_obj):
+        if self.date_format is None:
+            self.set_date_format()
+            
+        self.sheet_names[sheet_name].write_datetime(
+            row, column, datetime_obj, self.date_format)
+
+    def write(self, sheet_name, row, column, value):
+        self.sheet_names[sheet_name].write(row, column, value)
+
+    def setColumnWidth(self, sheet_name, column_names, width=12):
+        '''
+        column_names: list
+        '''
+        if isinstance(column_names, str):
+            self.sheet_names[sheet_name].set_column(
+                "{col}:{col}".format(col=column_names), width)
+        else:
+            for column in column_names:
+                self.sheet_names[sheet_name].set_column(
+                    "{col}:{col}".format(col=column), width)
+
+    def addFigure(self, sheet_name, x_src_sheet_name, x_start, x_end, y_src_sheet_name, y_start, y_end, position_cell="E2", chart_type='subtype',
+                subtype='straight', title='-', size = [1, 1], width = 720, height = 576, marker_type = 'automatic', x_axis_name = "", y_axis_name = "",
+                gridlines_visible = False, xmin = 0, ymin = 0, xmax = None, ymax = None):
+        '''
+        x_start example : "E3"
+        marker_type     : automatic, none, square, diamond, triangle, x, star, short_dash, long_dash, circle, plus
+        '''
+        chart = self.book.add_chart({'type': 'scatter', })
+        chart.set_size({'width': width, 'height': height})
+        # axis options
+        chart.set_x_axis({
+            'name': x_axis_name,
+            'min': xmin, 'max': xmax,
+            'major_gridlines': {
+                    'visible': gridlines_visible,
+                },
+        })
+
+        chart.set_y_axis({
+            'name': y_axis_name,
+            'min': ymin, 'max': ymax,
+            'major_gridlines': {
+                    'visible': gridlines_visible,
+                },
+        })
+
+
+        self.sheet_names[sheet_name].insert_chart(
+            position_cell, chart, {'x_scale': size[1], 'y_scale': size[0]})
+        chart.add_series({
+            'categories': '={sht}!{strt_x}:{end_x}'.format(sht=x_src_sheet_name, strt_x=x_start, end_x=x_end),
+            'values': '={sht}!{strt_y}:{end_y}'.format(sht=y_src_sheet_name, strt_y=y_start, end_y=y_end),
+            'name': title,
+            'marker': {'type': marker_type},
+            # 'trendline': {'type': 'linear'},
+        })
+        chart.set_legend({'position': 'bottom'})
+
+    def writeColumn(self, sheet_name, target_cell, content_list):
+        '''target_cell eg = A1'''
+        self.sheet_names[sheet_name].write_column(target_cell, content_list)
+
+    def getPlatform():
+        """Returns: Windows or Linux"""
+        return platform.system()
+
+
+    def open(self):
+        if self.getPlatform() == "Windows":
+            os.startfile(os.path.abspath(self.path))
+        else:
+            os.system(f"open {self.path}")
+
+    def toAlphaNumeric(self, row, column):
+        return xl_rowcol_to_cell(row, column)
+
+    def save(self):
+        continue_ = True
+        while continue_:
+            try:
+                self.book.close()
+                continue_ = False
+            except:
+                print("\t! Error writing the Excel file, make sure it is closed")
+                answer = input("\t> retry? (y/n): ")
+                continue_ = True if answer == "y" else False
+
+
+    def createPath(self, path_name, v = False):
+        path_name = os.path.dirname(path_name)
+        if path_name == '':
+            path_name = './'
+        if not os.path.isdir(path_name):
+            os.makedirs(path_name)
+            if v:
+                print(f"\t> created path: {path_name}")
+        
+        return path_name
+

ccfx/mssqlConnection.py

@@ -0,0 +1,228 @@
+'''
+a module that helps ease the management of MSSQL databases
+
+Author  : Celray James CHAWANDA
+Email   : celray.chawanda@outlook.com
+Licence : MIT 2023
+Repo    : https://github.com/celray
+
+Date    : 2023-07-20
+'''
+# imports
+
+import sys
+import urllib
+import sys
+import pandas
+import pyodbc
+from sqlalchemy import MetaData, Table, create_engine, func, select
+from shapely import wkt
+import geopandas
+
+
+# classes
+class mssql_connection:
+    def __init__(self, server, username, password, driver, trust_server_ssl = True) -> None:
+        self.server     = server
+        self.username   = username
+        self.password   = password
+        self.driver     = driver
+
+        self.trust_server_ssl     = trust_server_ssl
+        
+        self.connection = None
+        self.cursor     = None
+        self.db_name    = "TMP_CJames"
+        
+        self.databases  = []
+
+    def connect(self):
+        # Connect to the SQL Server instance
+        connection_string   = f'DRIVER={self.driver};SERVER={self.server};UID={self.username};PWD={self.password};TrustServerCertificate={"yes" if self.trust_server_ssl else "no"}'
+        try:
+            self.connection = pyodbc.connect(connection_string)
+            self.cursor = self.connection.cursor()
+            print(f"> connection to {self.server} established...")
+        except pyodbc.Error as e:
+            print("! error occurred while connecting to the SQL Server instance:")
+            print(e)
+
+
+    def listDatabases(self) -> list:
+        query = "SELECT name FROM sys.databases"
+        
+        if self.connection is None:
+            print("! there is no connection to the MSSQL server instance")
+            sys.exit(1)
+            
+        # Execute the query and fetch the results
+        try:
+            self.cursor = self.connection.cursor()
+            self.cursor.execute(query)
+            self.databases = [row[0] for row in self.cursor.fetchall()]
+            print("\n> List of available databases:")
+            for db in self.databases:
+                print(f"\t- {db}")
+        except pyodbc.Error as e:
+            print("! error occurred while fetching the list of databases:")
+            print(e)
+        
+        return self.databases
+    
+    
+    def listTables(self, db_name = None) -> list:
+        
+        if not db_name is None:
+            self.connect_db(db_name)
+            
+        query = """
+        SELECT TABLE_NAME
+        FROM INFORMATION_SCHEMA.TABLES
+        WHERE TABLE_TYPE = 'BASE TABLE'
+        """
+
+        try:
+            self.cursor = self.connection.cursor()
+            self.cursor.execute(query)
+            tables = [row[0] for row in self.cursor.fetchall()]
+            print("> list of tables in the active database:")
+            for table in tables:
+                print(f"\t- {table}")
+        except pyodbc.Error as e:
+            print("Error occurred while fetching the list of tables:")
+            print(e)
+        
+        return tables
+    
+        
+    def readTable(self, table_name:str, db_name:str = None, columns:list = None, geom_col:str = None, v = True):
+        if db_name is not None:
+            self.connect_db(db_name)
+
+        if columns is not None and geom_col is not None:
+            columns.append(f"{geom_col}.STAsText() as {geom_col}_wkt")
+            query = f"SELECT {','.join(columns)} FROM {table_name}"
+        elif columns is not None:
+            query = f"SELECT {','.join(columns)} FROM {table_name}"
+        elif geom_col is not None:
+            query = f"SELECT *, {geom_col}.STAsText() as {geom_col}_wkt FROM {table_name}"
+        else:
+            query = f"SELECT * FROM {table_name}"
+
+        # Load as a regular DataFrame
+        if v: print(f"> reading table: {table_name} from {self.db_name}")
+        df = pandas.read_sql(query, self.connection)
+
+        # Convert WKT column to a GeoPandas geometry column if needed
+        if geom_col is not None:
+            df[geom_col] = df[geom_col+"_wkt"].apply(wkt.loads)
+            df = geopandas.GeoDataFrame(df, geometry=geom_col)
+            
+        return df
+        
+    # Function to change the active database
+    def connectDB(self, db_name = None, v = True):
+        if not self.connection:
+            self.connect()
+        try:
+            self.cursor     = self.connection.cursor()
+            self.cursor.execute(f"USE {db_name if not db_name is None else self.db_name}")
+            self.db_name    = db_name if not db_name is None else self.db_name
+            self.cursor.commit()
+
+            if v: print(f"> changed active database to: {db_name if not db_name is None else self.db_name}")
+        except pyodbc.Error as e:
+            print("! error occurred while changing the active database:")
+            print(e)
+
+    def dataframeToSql(self, df, table_name, if_exists='fail', geom_col='geometry', v = True):
+        """
+        Write records stored in a DataFrame to a SQL database.
+        """
+        print(f"> saving data to table: {table_name}...")
+
+        # Create SQLAlchemy engine
+        params = urllib.parse.quote_plus(f'DRIVER={self.driver};SERVER={self.server};DATABASE={self.db_name};UID={self.username};PWD={self.password};TrustServerCertificate=yes')
+        engine = create_engine(f"mssql+pyodbc:///?odbc_connect={params}")
+
+        # Check if dataframe is a GeoDataFrame and has a geometry column
+        if isinstance(df, geopandas.GeoDataFrame) and geom_col in df.columns:
+            # Create a new column for WKT format
+            df[geom_col+'_wkt'] = df[geom_col].apply(lambda x: x.wkt)
+            
+            # Drop the original geometry column
+            df = df.drop(columns=[geom_col])
+            
+            # Write DataFrame to SQL table
+            df.to_sql(table_name, engine, if_exists=if_exists, index=False)
+
+            # Create a new connection and cursor
+            conn = engine.raw_connection()
+            cursor = conn.cursor()
+
+            # Convert the WKT column back to a geometry column in SQL Server
+            cursor.execute(f"ALTER TABLE [{table_name}] ADD [{geom_col}] geometry")
+            cursor.execute(f"UPDATE [{table_name}] SET [{geom_col}] = geometry::STGeomFromText([{geom_col}_wkt], 4326)")
+            
+            # Drop the WKT column
+            cursor.execute(f"ALTER TABLE [{table_name}] DROP COLUMN [{geom_col}_wkt]")
+            
+            conn.commit()
+
+            # Close the connection and cursor
+            cursor.close()
+            conn.close()
+
+        else:
+            # If dataframe is not a GeoDataFrame or doesn't have a geometry column, write it to SQL as usual
+            df.to_sql(table_name, engine, if_exists=if_exists, index=False)
+
+        if v:
+            print(f"> saved data to table: {table_name}...")
+
+
+
+    def modifySqlTable(self, df, table_name):
+        """
+        Replace an existing SQL table with a new one based on a DataFrame.
+
+        Parameters:
+        df : DataFrame
+        table_name : string
+            Name of SQL table
+        """
+        self.dataframe_to_sql(df, table_name, if_exists='replace')
+    
+    def dropTable(self, table_name, v = True):
+        """
+        Drops a table from the database.
+
+        Parameters:
+        table_name : string
+            Name of SQL table
+        """
+        
+        if not self.connection:
+            self.connect()
+
+        # Drop the table
+        self.cursor.execute(f"DROP TABLE IF EXISTS {table_name}")
+
+        # Commit the transaction
+        self.connection.commit()
+
+        if v: print(f"> deleted table {table_name}")
+
+    def deleteTable(self, table_name, v = True):
+        self.dropTable(table_name, v = v)
+
+    def close(self, v = True):
+        if self.connection:
+            self.connection.close()
+            self.connection = None
+            self.cursor = None
+        if v: print("> connection closed...")
+
+    def disconnect(self, v = True):
+        self.close(v = v)
+

ccfx/sqliteConnection.py

@@ -0,0 +1,302 @@
+'''
+a module that helps ease the management of sqlite databases
+
+Author  : Celray James CHAWANDA
+Email   : celray.chawanda@outlook.com
+Licence : MIT 2023
+Repo    : https://github.com/celray
+
+Date    : 2023-07-20
+'''
+
+# imports
+import sys
+import sqlite3
+import sys
+import pandas
+
+# classes
+class sqliteConnection:
+    def __init__(self, sqlite_database, connect = False):
+        self.db_name = sqlite_database
+        self.connection = None
+        self.cursor = None
+
+        if connect:
+            self.connect()
+
+    def connect(self, v=True):
+        self.connection = sqlite3.connect(self.db_name)
+        self.cursor = self.connection.cursor()
+        if v:
+            self.report("\t-> connection to " + self.db_name + " established...")
+
+    def updateValue(self, table_name, col_name, new_value, col_where1, val_1, v=False):
+        """
+        does not work yet!
+        """
+        if not new_value is None:
+            new_value = str(new_value)
+            self.cursor.execute("UPDATE " + table_name + " SET " + col_name +
+                                " = '" + new_value + "' WHERE " + col_where1 + " = " + val_1 + ";")
+        if new_value is None:
+            self.cursor.execute("UPDATE " + table_name + " SET " + col_name +
+                                " = ? " + " WHERE " + col_where1 + " = ?", (new_value, val_1))
+        # self.cursor.execute(sql_str)
+        if v:
+            self.report("\t -> updated {1} value in {0}".format(
+                self.db_name.split("/")[-1].split("\\")[-1], table_name))
+
+    def createTable(self, table_name, initial_field_name, data_type):
+        '''
+        can be text, real, etc
+        '''
+        try:
+            self.cursor.execute('''CREATE TABLE ''' + table_name +
+                                '(' + initial_field_name + ' ' + data_type + ')')
+            self.report("\t-> created table " + table_name + " in " + self.db_name)
+        except:
+            self.report("\t! table exists")
+
+    def renameTable(self, old_table_name, new_table_name, v=False):
+        """
+        this function gives a new name to an existing table and saves the changes
+        """
+        self.cursor.execute("ALTER TABLE " + old_table_name +
+                            " RENAME TO " + new_table_name)
+        if v:
+            self.report("\t-> renamed " + old_table_name + " to " + new_table_name)
+        self.commitChanges()
+
+    def tableExists(self, table_name):
+        self.cursor.execute("SELECT count(name) FROM sqlite_master WHERE type='table' AND name='{table_name}'".format(
+            table_name=table_name))
+        if self.cursor.fetchone()[0] == 1:
+            return True
+        else:
+            return False
+
+    def deleteRows(self, table_to_clean, col_where=None, col_where_value=None, v=False):
+        """
+
+        """
+
+        if (col_where is None) and (col_where_value is None):
+            self.connection.execute("DELETE FROM " + table_to_clean)
+
+        elif (not col_where is None) and (not col_where_value is None):
+            self.connection.execute(
+                "DELETE FROM " + table_to_clean + " WHERE " + col_where + " = " + col_where_value + ";")
+
+        else:
+            raise ("\t! not all arguments were provided for selective row deletion")
+
+        if v:
+            self.report("\t-> removed all rows from " + table_to_clean)
+
+    def deleteTable(self, table_name):
+        """
+        this function deletes the specified table
+        """
+        self.cursor.execute('''DROP TABLE ''' + table_name)
+        self.report("\t-> deleted table " + table_name + " from " + self.db_name)
+    
+    def dropTable(self, table_name):
+        self.deleteTable(table_name)
+
+    def undoChanges(self):
+        """
+        This function reverts the database to status before last commit
+        """
+        self.report("\t-> undoing changes to " + self.db_name + " then saving")
+        self.connection.rollback()
+        self.commitChanges()
+
+    def readTableAsDict(self, table_name, key_column = 'id'):
+        # Execute a SQL query to fetch all rows from your table
+        self.cursor = self.connection.execute(f"SELECT * FROM {table_name}")
+
+        # Fetch all rows as dictionaries
+        rows = [dict(zip([column[0] for column in self.cursor.description], row)) for row in self.cursor.fetchall()]
+
+        # Convert the list of dictionaries to a dictionary of dictionaries, 
+        # using the 'id' field as the key
+        data = {row[key_column]: row for row in rows}
+
+        return data
+
+    def getColumnsWithTypes(self, table_name):
+        c = self.cursor
+
+        # Prepare and execute a PRAGMA table_info statement
+        c.execute(f'PRAGMA table_info({table_name})')
+
+        # Fetch all rows and extract the column names and types
+        columns_with_types = {row[1]: row[2] for row in c.fetchall()}
+
+        return columns_with_types
+
+    def insertDictPartial(self, table_name, data_dict):
+        c = self.cursor
+
+        # Get the column names from the table
+        c.execute(f"PRAGMA table_info({table_name})")
+        columns = [row[1] for row in c.fetchall()]
+
+        # Filter the dictionary keys to match the column names
+        filtered_data = {k: v for k, v in data_dict.items() if k in columns}
+
+        # Prepare an INSERT INTO statement
+        fields = ', '.join(filtered_data.keys())
+        placeholders = ', '.join('?' for _ in filtered_data)
+        values = list(filtered_data.values())
+        sql = f'INSERT INTO {table_name} ({fields}) VALUES ({placeholders})'
+
+        # Execute the statement
+        c.execute(sql, values)
+
+        # Commit the changes
+        self.commitChanges()
+
+
+    def report(self, string, printing=False):
+        if printing:
+            print(f"\t> {string}")
+        else:
+            sys.stdout.write("\r" + string)
+            sys.stdout.flush()
+
+
+    def createTableFromDict(self, table_name, columns_with_types):
+
+        # Prepare a CREATE TABLE statement
+        fields = ', '.join(f'{column} {data_type}' for column, data_type in columns_with_types.items())
+        sql = f'CREATE TABLE IF NOT EXISTS {table_name} ({fields})'
+
+        # Execute the statement
+        self.connection.execute(sql)
+        self.commitChanges()
+
+
+    def insertDict(self, table_name, data):
+        
+        # Prepare an INSERT INTO statement for each dictionary
+        for id, row in data.items():
+            fields = ', '.join(row.keys())
+            placeholders = ', '.join('?' for _ in row)
+            values = list(row.values())
+            sql = f'INSERT INTO {table_name} ({fields}) VALUES ({placeholders})'
+
+            # Execute the statement
+            self.cursor.execute(sql, values)
+
+        # Commit the changes
+        self.connection.commit()
+
+
+
+    def readTableColumns(self, table_name, column_list="all"):
+        """
+        this function takes a list to be a string separated by commmas and
+        a table and puts the columns in the table into a variable
+
+        "all" to select all columns
+        """
+        if column_list == "all":
+            self.cursor = self.connection.execute(
+                "SELECT * from " + table_name)
+        else:
+            self.cursor = self.connection.execute(
+                "SELECT " + ",".join(column_list) + " from " + table_name)
+
+        list_of_tuples = []
+        for row in self.cursor:
+            list_of_tuples.append(row)
+        self.cursor = self.connection.cursor()
+        self.report("\t-> read selected table columns from " + table_name)
+        return list_of_tuples
+
+    def insertField(self, table_name, field_name, data_type, to_new_line=False, messages=True):
+        """
+        This will insert a new field into your sqlite database
+
+        table_name: an existing table
+        field_name: the field you want to add
+        data_type : text, integer, float or real
+        """
+        self.cursor.execute("alter table " + table_name +
+                            " add column " + field_name + " " + data_type)
+        if messages:
+            if to_new_line:
+                self.report(
+                    "\t-> inserted into table {0} field {1}".format(table_name, field_name))
+            else:
+                sys.stdout.write(
+                    "\r\t-> inserted into table {0} field {1}            ".format(table_name, field_name))
+                sys.stdout.flush()
+
+    def insertRow(self, table_name, ordered_content_list = [], dictionary_obj = {}, messages=False):
+        """
+        ordered_list such as ['ha','he','hi']
+        list should have data as strings
+        """
+        if len(ordered_content_list) > 0:
+            values_placeholder = ','.join(['?' if value is None else '?' for value in ordered_content_list])
+            values = [None if value is None else value for value in ordered_content_list]
+            self.cursor.execute("INSERT INTO " + table_name + " VALUES(" + values_placeholder + ")", values)
+        
+        elif len(dictionary_obj) > 0:
+            question_marks = ','.join(list('?'*len(dictionary_obj)))
+            keys = ','.join(dictionary_obj.keys())
+            values = tuple(dictionary_obj.values())
+            self.cursor.execute('INSERT INTO '+table_name+' ('+keys+') VALUES ('+question_marks+')', values)
+
+        if messages:
+            self.report("\t-> inserted row into " + table_name)
+
+    def insertRows(self, table_name, list_of_tuples, messages=False):
+        """
+        list_of_tuples such as [('ha','he','hi')'
+                                ('ha','he','hi')]
+        not limited to string data
+        """
+        self.cursor.executemany('INSERT INTO ' + table_name + ' VALUES (?{qmarks})'.format(
+            qmarks=",?" * (len(list_of_tuples[0]) - 1)), list_of_tuples)
+        if messages:
+            self.report("\t-> inserted rows into " + table_name)
+
+    def dumpCSV(self, table_name, file_name, index=False, v=False):
+        '''
+        save table to csv
+        '''
+        tmp_conn = sqlite3.connect(self.db_name)
+        df = pandas.read_sql_query(
+            "SELECT * FROM {tn}".format(tn=table_name), tmp_conn)
+        if index:
+            df.to_csv(file_name)
+        else:
+            df.to_csv(file_name, index=False)
+
+        if v:
+            self.report(
+                "\t-> dumped table {0} to {1}".format(table_name, file_name))
+
+    def commitChanges(self, v=False):
+        '''
+        save changes to the database.
+        '''
+        self.connection.commit()
+        number_of_changes = self.connection.total_changes
+        if v:
+            self.report(
+                "\t-> saved {0} changes to ".format(number_of_changes) + self.db_name)
+
+    def closeConnection(self, commit=True):
+        '''
+        disconnects from the database
+        '''
+        if commit:
+            self.commitChanges()
+        self.connection.close()
+        self.report("\t-> closed connection to " + self.db_name)
+