ccfx 1.0.5__tar.gz → 1.0.7__tar.gz

{ccfx-1.0.5/ccfx.egg-info → ccfx-1.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ccfx
-Version: 1.0.5
+Version: 1.0.7
 Summary: This package simplifies regular common actions for quick prototyping in a user friendly way
 Author-email: Celray James CHAWANDA <celray@chawanda.com>
 License-Expression: MIT
@@ -25,6 +25,7 @@ Requires-Dist: py7zr
 Requires-Dist: mutagen
 Requires-Dist: requests
 Requires-Dist: tqdm
+Requires-Dist: pillow
 Dynamic: license-file
 
 # ccfx

{ccfx-1.0.5 → ccfx-1.0.7}/ccfx/ccfx.py

@@ -37,6 +37,7 @@ from tqdm import tqdm
 import yt_dlp
 from typing import Optional
 from datetime import datetime, timedelta
+from PIL import Image
 
 # functions
 def listFiles(path: str, ext: Optional[str] = None) -> list:
@@ -1593,6 +1594,33 @@ def showProgress(count: int, end: int, message: str, barLength: int = 100) -> No
         print()
 
 
+def dualProgress(primaryCount: int, primaryEnd: int,
+                 secondaryCount: int, secondaryEnd: int,
+                 barLength: int = 40,
+                 message: str = '') -> None:
+    '''
+    Draw two full progress bars every frame, overwriting previous frame.
+    Bars are redrawn entirely each call.
+    '''
+
+    primaryPercent = float(primaryCount / primaryEnd * 100) if primaryEnd > 0 else 100
+    secondaryPercent = float(secondaryCount / secondaryEnd * 100) if secondaryEnd > 0 else 100
+
+    filledPrimary = int(barLength * primaryCount / primaryEnd) if primaryEnd > 0 else barLength
+    filledSecondary = int((barLength - filledPrimary) * secondaryCount / secondaryEnd) if secondaryEnd > 0 else barLength
+
+    startSection  = filledPrimary
+    middleSection = filledSecondary
+    endSection    = barLength - startSection - middleSection 
+
+    bar = '█' * startSection + '░' * middleSection + '-' * endSection
+    formattedPrimaryPercent = f'{primaryPercent:03.1f}'
+    formattedSecondaryPercent = f'{secondaryPercent:03.1f}'
+    print(f'\r{bar} {formattedPrimaryPercent.rjust(6)}% | {formattedSecondaryPercent.rjust(6)}% | {message}       ', end='', flush=True)
+    if primaryCount == primaryEnd and secondaryCount == secondaryEnd:
+        print(f'\r{bar} {formattedPrimaryPercent.rjust(6)}% | {formattedSecondaryPercent.rjust(6)}%                          ', end='', flush=True)
+
+
 def listAllFiles(folder, extension="*"):
     list_of_files = []
     # Getting the current work directory (cwd)

{ccfx-1.0.5 → ccfx-1.0.7}/ccfx/sqliteConnection.py

@@ -17,7 +17,7 @@ import pandas
 
 # classes
 class sqliteConnection:
-    def __init__(self, sqlite_database, connect = False):
+    def __init__(self, sqlite_database, connect = False) -> None:
         self.db_name = sqlite_database
         self.connection = None
         self.cursor = None
@@ -25,13 +25,13 @@ class sqliteConnection:
         if connect:
             self.connect()
 
-    def connect(self, v=True):
+    def connect(self, v=True) -> None:
         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):
+    def updateValue(self, table_name, col_name, new_value, col_where1, val_1, v=False) -> None:
         """
         Updates a single value in a specified table where the condition matches.
         
@@ -56,7 +56,7 @@ class sqliteConnection:
             raise Exception(f"Error updating value: {str(e)}")
         
 
-    def createTable(self, table_name, initial_field_name, data_type):
+    def createTable(self, table_name, initial_field_name, data_type) -> None:
         '''
         can be text, real, etc
         '''
@@ -67,7 +67,100 @@ class sqliteConnection:
         except:
             self.report("\t! table exists")
 
-    def renameTable(self, old_table_name, new_table_name, v=False):
+    def newTable(self, tableName, columnsDict, columnOrder=None, notNull=None, foreignKeys=None) -> None:
+        """
+        Create a new table based on dictionary of columns and types.
+        
+        Args:
+            tableName (str): Name of the table to create
+            columnsDict (dict): Dictionary with column names as keys and data types as values
+                                options:
+                                INTEGER, REAL, TEXT, BLOB, etc.
+                                Example: {'id': 'INTEGER PRIMARY KEY', 'name': 'TEXT', 'age': 'INTEGER'}
+
+            columnOrder (list, optional): List specifying the order of columns
+                                Example: ['name', 'age', 'id']
+
+            notNull (list, optional): List of column names that should have NOT NULL constraint
+                                Example: ['name', 'age']
+
+            foreignKeys (dict, optional): Dictionary defining foreign key constraints
+                                Format Option 1: {currentTableField: {foreignTable: foreignField}, 'onDelete': 'CASCADE'}
+                                Format Option 2: {currentTableField: {foreignTable: foreignField, 'onDelete': 'CASCADE'}}
+                
+                                onDelete options: CASCADE, SET NULL, RESTRICT, NO ACTION, SET DEFAULT
+                                Examples: 
+                                {'user_id': {'users': 'id'}, 'onDelete': 'CASCADE'}
+                                {'user_id': {'users': 'id', 'onDelete': 'SET NULL'}}
+
+        """
+        try:
+            # Determine column order
+            if columnOrder:
+                # Use specified order, but include any columns not in the order list at the end
+                orderedColumns = []
+                for col in columnOrder:
+                    if col in columnsDict:
+                        orderedColumns.append(col)
+                # Add any remaining columns not in the order list
+                for col in columnsDict:
+                    if col not in orderedColumns:
+                        orderedColumns.append(col)
+            else:
+                orderedColumns = list(columnsDict.keys())
+            
+            # Build column definitions
+            columnDefinitions = []
+            for col in orderedColumns:
+                definition = f"{col} {columnsDict[col]}"
+                
+                # Add NOT NULL constraint if specified
+                if notNull and col in notNull:
+                    definition += " NOT NULL"
+                
+                columnDefinitions.append(definition)
+            
+            # Handle foreign key constraints
+            if foreignKeys:
+                onDeleteClause = ""
+                if 'onDelete' in foreignKeys:
+                    onDeleteClause = f" ON DELETE {foreignKeys['onDelete']}"
+                
+                for currentField, foreignRef in foreignKeys.items():
+                    if currentField != 'onDelete':  # Skip the onDelete key
+                        if isinstance(foreignRef, dict):
+                            # Check if onDelete is specified at field level
+                            if 'onDelete' in foreignRef:
+                                fieldOnDelete = f" ON DELETE {foreignRef['onDelete']}"
+                                # Get the actual foreign table and field (skip onDelete key)
+                                foreignTable = None
+                                foreignField = None
+                                for key, value in foreignRef.items():
+                                    if key != 'onDelete':
+                                        foreignTable = key
+                                        foreignField = value
+                                        break
+                            else:
+                                # Use global onDelete clause and assume dict format {table: field}
+                                fieldOnDelete = onDeleteClause
+                                foreignTable = list(foreignRef.keys())[0]
+                                foreignField = foreignRef[foreignTable]
+                            
+                            if foreignTable and foreignField:
+                                foreignKeyDef = f"FOREIGN KEY ({currentField}) REFERENCES {foreignTable}({foreignField}){fieldOnDelete}"
+                                columnDefinitions.append(foreignKeyDef)
+            
+            # Create the SQL statement
+            columnsSQL = ', '.join(columnDefinitions)
+            sql = f"CREATE TABLE {tableName} ({columnsSQL})"
+            
+            self.cursor.execute(sql)
+            self.report(f"\t-> created table {tableName} in {self.db_name}")
+            
+        except Exception as e:
+            self.report(f"\t! error creating table {tableName}: {str(e)}")
+
+    def renameTable(self, old_table_name, new_table_name, v=False) -> None:
         """
         this function gives a new name to an existing table and saves the changes
         """
@@ -77,7 +170,7 @@ class sqliteConnection:
             self.report("\t-> renamed " + old_table_name + " to " + new_table_name)
         self.commitChanges()
 
-    def tableExists(self, table_name):
+    def tableExists(self, table_name) -> bool:
         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:
@@ -85,7 +178,7 @@ class sqliteConnection:
         else:
             return False
 
-    def deleteRows(self, table_to_clean, col_where=None, col_where_value=None, v=False):
+    def deleteRows(self, table_to_clean, col_where=None, col_where_value=None, v=False) -> None:
         """
 
         """
@@ -103,17 +196,17 @@ class sqliteConnection:
         if v:
             self.report("\t-> removed all rows from " + table_to_clean)
 
-    def deleteTable(self, table_name):
+    def deleteTable(self, table_name) -> None:
         """
         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):
+
+    def dropTable(self, table_name) -> None:
         self.deleteTable(table_name)
 
-    def undoChanges(self):
+    def undoChanges(self) -> None:
         """
         This function reverts the database to status before last commit
         """
@@ -121,7 +214,7 @@ class sqliteConnection:
         self.connection.rollback()
         self.commitChanges()
 
-    def readTableAsDict(self, table_name, key_column = 'id'):
+    def readTableAsDict(self, table_name, key_column: str = 'id') -> dict:
         # Execute a SQL query to fetch all rows from your table
         self.cursor = self.connection.execute(f"SELECT * FROM {table_name}")
 
@@ -134,7 +227,7 @@ class sqliteConnection:
 
         return data
 
-    def getColumnsWithTypes(self, table_name):
+    def getColumnsWithTypes(self, table_name) -> dict:
         c = self.cursor
 
         # Prepare and execute a PRAGMA table_info statement
@@ -145,7 +238,7 @@ class sqliteConnection:
 
         return columns_with_types
 
-    def insertDictPartial(self, table_name, data_dict):
+    def insertDictPartial(self, table_name, data_dict) -> None:
         c = self.cursor
 
         # Get the column names from the table
@@ -168,7 +261,7 @@ class sqliteConnection:
         self.commitChanges()
 
 
-    def report(self, string, printing=False):
+    def report(self, string, printing=False) -> None:
         if printing:
             print(f"\t> {string}")
         else:
@@ -176,7 +269,7 @@ class sqliteConnection:
             sys.stdout.flush()
 
 
-    def createTableFromDict(self, table_name, columns_with_types):
+    def createTableFromDict(self, table_name, columns_with_types) -> None:
 
         # Prepare a CREATE TABLE statement
         fields = ', '.join(f'{column} {data_type}' for column, data_type in columns_with_types.items())
@@ -187,7 +280,7 @@ class sqliteConnection:
         self.commitChanges()
 
 
-    def insertDict(self, table_name, data):
+    def insertDict(self, table_name, data) -> None:
         
         # Prepare an INSERT INTO statement for each dictionary
         for id, row in data.items():
@@ -204,7 +297,7 @@ class sqliteConnection:
 
 
 
-    def readTableColumns(self, table_name, column_list="all"):
+    def readTableColumns(self, table_name, column_list="all") -> list:
         """
         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
@@ -225,7 +318,7 @@ class sqliteConnection:
         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):
+    def insertField(self, table_name, field_name, data_type, to_new_line=False, messages=True) -> None:
         """
         This will insert a new field into your sqlite database
 
@@ -244,7 +337,7 @@ class sqliteConnection:
                     "\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):
+    def insertRow(self, table_name, ordered_content_list = [], dictionary_obj = {}, messages=False) -> None:
         """
         ordered_list such as ['ha','he','hi']
         list should have data as strings
@@ -263,7 +356,7 @@ class sqliteConnection:
         if messages:
             self.report("\t-> inserted row into " + table_name)
 
-    def insertRows(self, table_name, list_of_tuples, messages=False):
+    def insertRows(self, table_name, list_of_tuples, messages=False) -> None:
         """
         list_of_tuples such as [('ha','he','hi')'
                                 ('ha','he','hi')]
@@ -274,7 +367,7 @@ class sqliteConnection:
         if messages:
             self.report("\t-> inserted rows into " + table_name)
 
-    def dumpCSV(self, table_name, file_name, index=False, v=False):
+    def dumpCSV(self, table_name, file_name, index=False, v=False) -> None:
         '''
         save table to csv
         '''
@@ -300,7 +393,11 @@ class sqliteConnection:
             self.report(
                 "\t-> saved {0} changes to ".format(number_of_changes) + self.db_name)
 
-    def closeConnection(self, commit=True):
+    def commit(self, v=False) -> None:
+        '''proxy to commitChanges'''
+        self.commitChanges(v)
+
+    def closeConnection(self, commit=True) -> None:
         '''
         disconnects from the database
         '''

{ccfx-1.0.5 → ccfx-1.0.7/ccfx.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ccfx
-Version: 1.0.5
+Version: 1.0.7
 Summary: This package simplifies regular common actions for quick prototyping in a user friendly way
 Author-email: Celray James CHAWANDA <celray@chawanda.com>
 License-Expression: MIT
@@ -25,6 +25,7 @@ Requires-Dist: py7zr
 Requires-Dist: mutagen
 Requires-Dist: requests
 Requires-Dist: tqdm
+Requires-Dist: pillow
 Dynamic: license-file
 
 # ccfx

{ccfx-1.0.5 → ccfx-1.0.7}/ccfx.egg-info/requires.txt

@@ -13,3 +13,4 @@ py7zr
 mutagen
 requests
 tqdm
+pillow

{ccfx-1.0.5 → ccfx-1.0.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ccfx"
-version = "1.0.5"
+version = "1.0.7"
 description = "This package simplifies regular common actions for quick prototyping in a user friendly way"
 readme = "README.md"
 license = "MIT"
@@ -30,6 +30,7 @@ dependencies = [
     "mutagen",
     "requests",
     "tqdm",
+    "pillow",
 ]
 
 [project.urls]