p3lib 1.1.100__tar.gz → 1.1.102__tar.gz

{p3lib-1.1.100 → p3lib-1.1.102}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: p3lib
-Version: 1.1.100
+Version: 1.1.102
 Summary: A group of python modules for networking, plotting data, config storage, automating boot scripts, ssh access and user input output.
 Home-page: https://github.com/pjaos/p3lib
 Author: Paul Austen

{p3lib-1.1.100 → p3lib-1.1.102}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = p3lib
-version = 1.1.100
+version = 1.1.102
 author = Paul Austen
 author_email = pausten.os@gmail.com
 description = A group of python modules for networking, plotting data, config storage, automating boot scripts, ssh access and user input output.

p3lib-1.1.102/src/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-1.1.102/src/p3lib/gnome_desktop_app.py

@@ -0,0 +1,132 @@
+#!/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 or it's parent.
+           @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):
+                    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=python3 {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"""
+        if os.path.isfile(self._gnome_desktop_file):
+            os.remove(self._gnome_desktop_file)
+
+"""
+    Example usage
+    gda = GnomeDesktopApp('savings.png')
+    gda.create(overwrite=True)
+"""
+
+
+
+

{p3lib-1.1.100 → p3lib-1.1.102}/src/p3lib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: p3lib
-Version: 1.1.100
+Version: 1.1.102
 Summary: A group of python modules for networking, plotting data, config storage, automating boot scripts, ssh access and user input output.
 Home-page: https://github.com/pjaos/p3lib
 Author: Paul Austen

{p3lib-1.1.100 → p3lib-1.1.102}/src/p3lib.egg-info/SOURCES.txt

@@ -9,6 +9,8 @@ src/p3lib/bokeh_gui.py
 src/p3lib/boot_manager.py
 src/p3lib/conduit.py
 src/p3lib/database_if.py
+src/p3lib/file_io.py
+src/p3lib/gnome_desktop_app.py
 src/p3lib/helper.py
 src/p3lib/json_networking.py
 src/p3lib/mqtt_rpc.py