p3lib 1.1.108__py2.py3-none-any.whl

p3lib/database_if.py

@@ -0,0 +1,289 @@
+#!/usr/bin/env python
+
+import  MySQLdb as mysqldb
+from    datetime import datetime
+
+class DBConfig(object):
+    """@brief responsible for holding the attributes if the database configuration."""
+
+    DEFAULT_TCP_PORT = 3306
+
+    def __init__(self):
+        self.serverAddress      =   ""
+        self.serverPort         =   DBConfig.DEFAULT_TCP_PORT
+        self.username           =   ""
+        self.password           =   ""
+        self.dataBaseName       =   ""
+        self.uio                =   None
+
+class DatabaseIFError(Exception):
+  pass
+
+class DatabaseIF(object):
+    """@brief Responsible for providing an interface to a database to allow
+              Creation of database
+              Creation of tables
+              Execution of database sql commands
+              """
+
+    """@brief Set this to True to see the SQL statements executed."""
+    DEBUG=False
+
+    @staticmethod
+    def CheckTableExists(connection, tableName):
+        """@brief Check if a table exists in the selected database.
+           @param connection The connection to the database.
+           @param tableName The name of the table to check for.
+           @return True if the table exists, False if not."""
+        cursor = connection.cursor()
+        cmd="""SELECT COUNT(*) FROM information_schema.tables WHERE table_name = '{0}'""".format(tableName.replace('\'', '\'\''))
+        cursor.execute(cmd)
+        tableExists = cursor.fetchone()[0] == 1
+        cursor.close()
+        return tableExists
+
+    @staticmethod
+    def GetValidColName(colName):
+        """@brief Get a valid database column name."""
+
+        VALID_CHAR_LIST = "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ$_"
+        for aChar in colName:
+            if aChar not in VALID_CHAR_LIST:
+                colName = colName.replace(aChar, '_')
+
+        return colName
+
+    @staticmethod
+    def CreateTable(connection, tableName, tableSchemaDict):
+        """"@brief Create a table in the currently USED database..
+            @param connection The connection to the database.
+            @param param:
+            @param tableSchemaDict A python dictionary that defines the table schema.
+                                   Each dictionary key is the name of the column in the table.
+                                   Each associated value is the SQL definition of the column type (E.G VARCHAR(64), FLOAT(5,2) etc)."""
+        cursor = connection.cursor()
+
+        sqlCmd = 'CREATE TABLE IF NOT EXISTS `{}` ('.format(tableName)
+        for colName in list(tableSchemaDict.keys()):
+            colDef = tableSchemaDict[colName]
+            correctedColName = DatabaseIF.GetValidColName(colName)
+            sqlCmd = sqlCmd + "`{}` {},\n".format(correctedColName, colDef)
+
+        sqlCmd = sqlCmd[:-2]
+        sqlCmd = sqlCmd + ");"
+        DatabaseIF.ExecuteSQL(connection, cursor, sqlCmd)
+        cursor.close()
+
+    @staticmethod
+    def GetQuotedValue(value):
+        return '\"{}"'.format(str(value))
+
+    @staticmethod
+    def InsertRow(connection, tableName, myDict):
+        """@brief Insert a row into the table."""
+        cursor = connection.cursor()
+        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        myDict['TIMESTAMP'] = timestamp
+
+        keyList = list(myDict.keys())
+        valueList = []
+        for key in keyList:
+            valueList.append(str(myDict[key]))
+
+        sql = 'INSERT INTO `' + tableName
+        sql += '` ('
+        sql += ', '.join(keyList)
+        sql += ') VALUES ('
+        sql += ', '.join(map(DatabaseIF.GetQuotedValue, valueList))
+        sql += ');'
+        DatabaseIF.ExecuteSQL(connection, cursor, sql)
+        cursor.close()
+
+    @staticmethod
+    def ExecuteSQL(connection, cursor, cmd):
+        try:
+            if DatabaseIF.DEBUG:
+                print('ExecuteSQL(): ',cmd)
+            rowsAffected = cursor.execute(cmd)
+            connection.commit()
+        except:
+            connection.rollback();
+            raise
+
+        return rowsAffected
+
+    @staticmethod
+    def GetInsertableDict(self, rxDict, tableSchema):
+        """@brief Convert the dict into a dict that can be stored in the database.
+                  All the keys must have names that only contain characters that are valid for table columns.
+                  Only those keys that are in the tableSchema will be inserted."""
+        keys = list(rxDict.keys())
+        convertedDict = {}
+        for key in keys:
+            colName = DatabaseIF.GetValidColName(key)
+            #Only add the keys that we wish to store in the database
+            if colName in list(tableSchema.keys()):
+                convertedDict[colName] = rxDict[key]
+        return convertedDict
+
+    def __init__(self, config):
+        """@brief Constructor
+           @param config The database configuration instance."""
+        self._dbConfig = config
+
+        self._dbCon = None
+
+    def _info(self, msg):
+        if self._dbConfig.uio:
+            self._dbConfig.uio.info(msg)
+
+
+    def _debug(self, msg):
+        if self._dbConfig.uio and self._dbConfig.uio.debug:
+            self._dbConfig.uio.debug(msg)
+
+    def connect(self):
+        """@brief connect to the database server."""
+        self._info("Connecting to {}:{} (database = {})".format(self._dbConfig.serverAddress, self._dbConfig.serverPort, self._dbConfig.dataBaseName))
+        self._dbCon = mysqldb.Connection(host=self._dbConfig.serverAddress,\
+                                                port=self._dbConfig.serverPort,\
+                                                user=self._dbConfig.username,\
+                                                passwd=self._dbConfig.password,\
+                                                db=self._dbConfig.dataBaseName)
+        self._info("Connected")
+
+    def connectNoDB(self):
+        """@brief connect to the database server."""
+        self._info("Connecting to database server @ {}:{}".format(self._dbConfig.serverAddress, self._dbConfig.serverPort))
+        self._dbCon = mysqldb.Connection(host=self._dbConfig.serverAddress,\
+                                                port=self._dbConfig.serverPort,\
+                                                user=self._dbConfig.username,\
+                                                passwd=self._dbConfig.password)
+        self._info("Connected")
+
+    def checkTableExists(self, tableName):
+        """@brief Check if a table exists in any database.
+           @param tableName The name of the table to check for.
+           @return True if the table exists, False if not."""
+        cursor = self._dbCon.cursor()
+        cmd="""SELECT COUNT(*) FROM information_schema.tables WHERE table_name = '{0}'""".format(tableName.replace('\'', '\'\''))
+        self._debug("EXECUTE SQL: {}".format(cmd))
+        #self.executeSQL(cmd)
+        cursor.execute(cmd)
+        tableExists = cursor.fetchone()[0] == 1
+        cursor.close()
+        return tableExists
+
+    def _createTable(self, tableName, tableSchemaDict):
+        """"@brief Create a table in the currently used database..
+            @param tableName The name of the database table.
+            @param tableSchemaDict A python dictionary that defines the table schema.
+                                   Each dictionary key is the name of the column in the table.
+                                   Each associated value is the SQL definition of the column type (E.G VARCHAR(64), FLOAT(5,2) etc)."""
+        cursor = self._dbCon.cursor()
+
+        sqlCmd = 'CREATE TABLE IF NOT EXISTS `{}` ('.format(tableName)
+        for colName in list(tableSchemaDict.keys()):
+            colDef = tableSchemaDict[colName]
+            correctedColName = DatabaseIF.GetValidColName(colName)
+            sqlCmd = sqlCmd + "`{}` {},\n".format(correctedColName, colDef)
+
+        sqlCmd = sqlCmd[:-2]
+        sqlCmd = sqlCmd + ");"
+        self.executeSQL(sqlCmd)
+        cursor.close()
+
+    def createTable(self, tableName, tableSchemaDict):
+        """@brief Create the table in the connected database.
+           @param tableName The table we're innterested in.
+           @param tableSchemaDict The schema for the table in dict form."""
+        self._createTable(tableName, tableSchemaDict)
+
+    def getTableRowCount(self, tableName):
+        """@brief Get the number of rows in a table.
+           @param tableName The name of the table. 
+           @return the number of rows in the table or -1 if not found."""
+        count = -1
+        cmd = "SELECT COUNT(*) as count from {};".format(tableName)
+        retList = self.executeSQL(cmd)
+        if len(retList) > 0:
+            count = retList[0]['count']
+        return count
+    
+    def deleteRows(self, tableName, rowCount):
+        """@brief Delete rows from a table.
+           @param tableName The name of the table. 
+           @param rowCount The number of rows to delete."""
+        cmd = "DELETE FROM {} LIMIT {};".format(tableName, rowCount)
+        self.executeSQL(cmd)
+        
+    def ensureTableExists(self, tableName, tableSchemaDict, autoCreate):
+        """@brief Check that the table a table exists in the database.
+           @param tableName The table we're interested in.
+           @param tableSchemaDict The schema for the table in dict form.
+           @param autoCreate Now redundant. It used to be the case that if True then auto create the table."""
+        self._createTable(tableName, tableSchemaDict)
+
+    def insertRow(self, dataDict, tableName, tableSchemaDict):
+        """@brief Insert a row into a database table.
+                Must have previously connected to the database.
+           @param dataDict The dict holding the table data
+           @param tableName The name of the table to insert data into
+           @param tableSchemaDict The schema for the database table."""
+        insertableDict = DatabaseIF.GetInsertableDict(tableName, dataDict, tableSchemaDict)
+        cursor = self._dbCon.cursor()
+        timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        insertableDict['TIMESTAMP'] = timestamp
+
+        keyList = list(insertableDict.keys())
+        valueList = []
+        for key in keyList:
+            valueList.append(str(insertableDict[key]))
+
+        sql = 'INSERT INTO `' + tableName
+        sql += '` ('
+        sql += ', '.join(keyList)
+        sql += ') VALUES ('
+        sql += ', '.join(map(DatabaseIF.GetQuotedValue, valueList))
+        sql += ');'
+        self.executeSQL(sql)
+        cursor.close()
+
+    def executeSQL(self, sqlCmd):
+        """@brief execute an SQL cmd"""
+        self._debug("EXECUTE SQL: {}".format(sqlCmd))
+        dictCursor = self._dbCon.cursor(mysqldb.cursors.DictCursor)
+
+        dictCursor.execute(sqlCmd)
+        resultDict = dictCursor.fetchall()
+        self._dbCon.commit()
+        return resultDict
+
+    def disconnect(self):
+        """@brief Disconnect from the database server."""
+        try:
+            if self._dbCon:
+                self._dbCon.close()
+                self._dbCon = None
+                self._info("Disconnected from {}:{}".format(self._dbConfig.serverAddress, self._dbConfig.serverPort))
+        except:
+            pass
+
+    def createDatabase(self):
+        """@brief Create the database"""
+        sql = "CREATE DATABASE `{}`;".format(self._dbConfig.dataBaseName)
+        self.executeSQL(sql)
+        self._info("Created {} database.".format(self._dbConfig.dataBaseName))
+
+    def dropDatabase(self):
+        """@brief Delete the database"""
+        sql = "DROP DATABASE `{}`;".format(self._dbConfig.dataBaseName)
+        self.executeSQL(sql)
+        self._info("Deleted {} database.".format(self._dbConfig.dataBaseName))
+
+    def dropTable(self, tableName):
+        """@brief Delete a table in the database
+           @param tableName The table to drop."""
+        sql = "DROP TABLE `{}`;".format(tableName)
+        self.executeSQL(sql)
+        self._info("Deleted {} database table.".format(tableName))

p3lib/file_io.py

@@ -0,0 +1,154 @@
+import json
+import os
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+from cryptography.hazmat.primitives.hashes import SHA256
+from cryptography.hazmat.backends import default_backend
+from cryptography.fernet import Fernet
+from base64 import urlsafe_b64encode
+
+class CryptFile(object):
+    """@brief Responsible for encrypting and decrypting data to/from files using a password."""
+
+    def __init__(self,
+                 filename: str,
+                 password: str,
+                 add_enc_extension: bool = True,
+                 dict_data: bool = True):
+        """@brief Constructor
+           @param filename The filename to save the data into.
+           @param password The password to used encrypt data to and load encrypted data from file.
+           @param add_enc_extension If True then the .enc extension is added to the filename
+                                    supplied.
+           @param dict_data If True the data is a python dictionary."""
+        self._filename = filename
+        self._password = password
+        self._add_enc_extension = add_enc_extension
+        self._dict_data = dict_data
+
+        if not self._filename:
+            raise Exception("No filename defined to save data to.")
+
+        if len(self._filename) < 1:
+            raise Exception("No filename defined. String length = 0.")
+
+        if not self._password:
+            raise Exception("No password defined to encrypt/decrypt data.")
+
+        if len(self._password) < 1:
+            raise Exception("No password defined. String length = 0.")
+
+        self._add_extension()
+
+    def save(self,
+             data):
+        """@brief Save the data to an encrypted file.
+           @param data The data to be encrypted.
+        """
+        encrypted_data = self._encrypt_data(data)
+        with open(self._filename, "wb") as file:
+            file.write(encrypted_data)
+
+    def load(self):
+        """@brief Load data from an encrypted file.
+           @return The decrypted data.
+        """
+        with open(self._filename, "rb") as file:
+            data_bytes = file.read()
+        return self._decrypt_data(data_bytes)
+
+    def _decrypt_data(self, encrypted_data):
+        # Extract the salt (first 16 bytes) from the encrypted data
+        salt = encrypted_data[:16]
+        encrypted_content = encrypted_data[16:]
+        key = self._derive_key_from_password(salt)
+        fernet = Fernet(key)
+        decrypted_data = fernet.decrypt(encrypted_content)
+        if self._dict_data:
+             # Convert bytes back to a dict
+            data = json.loads(decrypted_data.decode())
+
+        else:
+            data = decrypted_data
+
+        return  data
+
+    def get_file(self):
+        """@return Get the name of the encrypted file."""
+        return self._filename
+
+    def _add_extension(self):
+        """@brief Add the enc extension to the filename if required."""
+        if self._add_enc_extension and self._filename and not self._filename.endswith('.enc') :
+            self._filename = self._filename + ".enc"
+
+    def _derive_key_from_password(self,
+                                  salt: bytes) -> bytes:
+        kdf = PBKDF2HMAC(
+            algorithm=SHA256(),
+            length=32,
+            salt=salt,
+            iterations=100_000,
+            backend=default_backend(),
+        )
+        return urlsafe_b64encode(kdf.derive(self._password.encode()))
+
+    def _encrypt_data(self,
+                      data):
+        # Generate a random salt for key derivation
+        salt = os.urandom(16)
+        key = self._derive_key_from_password(salt)
+        fernet = Fernet(key)
+        # If we expect a dict
+        if self._dict_data:
+            data_bytes = json.dumps(data).encode()  # Convert JSON to bytes
+
+        # else check we have bytes
+        elif isinstance(data, bytes):
+            data_bytes = data
+
+        else:
+            raise Exception("data to be stored is not a bytes instance.")
+
+        encrypted_data = fernet.encrypt(data_bytes)
+        return salt + encrypted_data  # Store the salt with the encrypted data
+
+# Example usage
+if __name__ == "__main__":
+
+    password = input("Enter a password for encryption: ")
+
+    # JSON data to encrypt
+    json_data = {
+        "name": "Alice",
+        "age": 30,
+        "is_admin": True,
+        "preferences": {
+            "theme": "dark",
+            "language": "English"
+        }
+    }
+
+    filename = "afile.txt"
+
+    # Save and load a python dict
+    cjf = CryptFile(filename=filename,
+                password=password)
+    cjf.save(json_data)
+    print(f"Saved {cjf.get_file()}")
+
+    decrypted_data = cjf.load()
+    print(f"Decrypted data: {decrypted_data}")
+
+
+    # Save and load data bytes
+    data_bytes = "123".encode()
+    cjf = CryptFile(filename=filename,
+                    password=password,
+                    dict_data=False)
+    cjf.save(data_bytes)
+    print(f"Saved {cjf.get_file()}")
+
+    decrypted_data = cjf.load()
+    print("Decrypted data:")
+    for _byte in decrypted_data:
+        print(f"_byte={_byte}")

p3lib/gnome_desktop_app.py

@@ -0,0 +1,146 @@
+#!/bin/env python3
+
+import os
+import sys
+import platform
+
+class GnomeDesktopApp(object):
+    """@brief Responsible for adding and removing gnome desktop files for launching applications on a Linux system."""
+
+    @staticmethod
+    def IsLinux():
+        """@return True if running on a Linux platform."""
+        linux = False
+        if platform.system() == "Linux":
+            linux = True
+        return linux
+
+    def __init__(self, icon_file, app_name=None, comment='', categories='Utility;Application;'):
+        """@brief Constructor.
+           @param icon_file  The name of the icon file. This can be an absolute file name the filename on it's own.
+                             If just a filename is passed then the icon file must sit in a folder named 'assets'.
+                             This assets folder must be in the same folder as the startup file, it's parent or
+                             the python3 site packages folder.
+           @param app_name   The name of the application.
+                             If not defined then the name of the program executed at startup is used.
+                             This name has _ and - character replace with space characters and each
+                             word starts with a capital letter.
+           @param comment    This comment should detail what the program does and is stored
+                             in the gnome desktop file that is created.
+           @param categories The debian app categories. default='Utility;Application;'.
+        """
+        if not GnomeDesktopApp.IsLinux():
+            raise Exception("The GnomeDesktopApp() class cannot be instantiated on a non Linux platform")
+        self._startup_file = self._get_startup_file()
+        self._gnome_desktop_file = None
+        self._app_name = self._get_app_name()
+        self._check_icon(icon_file)
+        self._comment = comment
+        self._categories = categories
+        self._gnome_desktop_file = self._get_gnome_desktop_file()
+
+    def _get_startup_file(self):
+        """@return Get the abs name of the program first started."""
+        return os.path.abspath(sys.argv[0])
+
+    def _get_app_name(self, app_name=None):
+        """@brief Get the name of the app.
+           @param app_name The name of the app or None. If None then the name of the app is the
+                  basename of the startup file minus it's extension.
+           @return The name of the app."""
+        if not app_name:
+            # Get just the name of the file
+            app_name = os.path.basename(self._startup_file)
+            # Remove file extension
+            app_name = os.path.splitext(app_name)[0]
+            app_name = app_name.replace('_', ' ')
+            app_name = app_name.replace('-', ' ')
+            app_name = app_name.title()
+        return app_name
+
+    def _check_icon(self, icon_file):
+        """@brief Check that the icon file exists as this is required for the gnome desktop entry.
+           @param icon_file The name of the icon file.
+           return None"""
+        self._abs_icon_file = os.path.abspath(icon_file)
+        if not os.path.isfile(self._abs_icon_file):
+            startup_path = os.path.dirname(self._startup_file)
+            path1 = os.path.join(startup_path, 'assets')
+            self._abs_icon_file = os.path.join(path1, icon_file)
+            if not os.path.isfile(self._abs_icon_file):
+                startup_parent_path = os.path.join(startup_path, '..')
+                path2 = os.path.join(startup_parent_path, 'assets')
+                self._abs_icon_file = os.path.join(path2, icon_file)
+                if not os.path.isfile(self._abs_icon_file):
+                    # Try all the site packages folders we know about.
+                    for path in sys.path:
+                        if 'site-packages' in path:
+                            site_packages_path = path
+                            path3 = os.path.join(site_packages_path, 'assets')
+                            self._abs_icon_file = os.path.join(path3, icon_file)
+                            if os.path.isfile(self._abs_icon_file):
+                                return self._abs_icon_file
+
+                    raise Exception(f"{self._app_name} icon file ({icon_file}) not found.")
+
+    def _get_gnome_desktop_file(self):
+        """@brief Determine and return the name of the gnome desktop file.
+           @return The gnome desktop file."""
+        # Get just the name of the file
+        desktop_file_name = os.path.basename(self._startup_file)
+        # Remove file extension
+        desktop_file_name = os.path.splitext(desktop_file_name)[0]
+        if not desktop_file_name.endswith('.desktop'):
+            desktop_file_name = desktop_file_name + '.desktop'
+        home_folder = os.path.expanduser("~")
+        gnome_desktop_apps_folder = os.path.join(home_folder, '.local/share/applications')
+        gnome_desktop_file = os.path.join(gnome_desktop_apps_folder, desktop_file_name)
+        return gnome_desktop_file
+
+    def _create_gnome_desktop_file(self):
+        """@brief Create the gnome desktop file for this app."""
+        if os.path.isfile(self._gnome_desktop_file):
+            raise Exception(f"{self._gnome_desktop_file} file already exists.")
+        lines = []
+        lines.append('[Desktop Entry]')
+        lines.append('Version=1.0')
+        lines.append('Type=Application')
+        lines.append('Encoding=UTF-8')
+        lines.append(f'Name={self._app_name}')
+        lines.append(f'Comment={self._comment}')
+        lines.append(f'Icon={self._abs_icon_file}')
+        lines.append(f'Exec={self._startup_file}')
+        lines.append('Terminal=false')
+        lines.append(f'Categories={self._categories}')
+
+        with open(self._gnome_desktop_file, "w", encoding="utf-8") as fd:
+            fd.write("\n".join(lines))
+
+    def create(self, overwrite=False):
+        """@brief Create a desktop icon.
+           @param overwrite If True overwrite any existing file. If False raise an error if the file is already present."""
+        # If this file not found error
+        if not os.path.isfile(self._startup_file):
+            raise Exception(f"{self._startup_file} file not found.")
+        if overwrite:
+            self.delete()
+        self._create_gnome_desktop_file()
+
+    def delete(self):
+        """@brief Delete the gnome desktop file if present.
+           @return True if a desktop file was deleted."""
+        deleted = False
+        if os.path.isfile(self._gnome_desktop_file):
+            os.remove(self._gnome_desktop_file)
+            deleted = True
+        return deleted
+
+"""
+    Example usage
+    gda = GnomeDesktopApp('savings.png')
+    gda.create(overwrite=True)
+"""
+
+
+
+