dtPyAppFramework 1.5.2__tar.gz → 2.0__tar.gz

{dtpyappframework-1.5.2/src/dtPyAppFramework.egg-info → dtpyappframework-2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dtPyAppFramework
-Version: 1.5.2
+Version: 2.0
 Summary: A Python library for common features in application development.
 Author-email: Digital-Thought <dev@digital-thought.org>
 Maintainer-email: Digital-Thought <dev@digital-thought.org>
@@ -54,13 +54,13 @@ Requires-Dist: colorlog
 Requires-Dist: psutil
 Requires-Dist: pybase64
 Requires-Dist: boto3
-Requires-Dist: cryptography==39.0.2
+Requires-Dist: cryptography
 Requires-Dist: azure-identity
 Requires-Dist: azure-keyvault-secrets
-Requires-Dist: pykeystore
 Requires-Dist: pytest-mock
 Requires-Dist: pytest-watch
 Requires-Dist: pytest
+Requires-Dist: watchdog
 
 # dtPyAppFramework
 

{dtpyappframework-1.5.2 → dtpyappframework-2.0}/requirements.txt

@@ -3,10 +3,10 @@ colorlog
 psutil
 pybase64
 boto3
-cryptography==39.0.2
+cryptography
 azure-identity
 azure-keyvault-secrets
-pykeystore
 pytest-mock
 pytest-watch
-pytest
+pytest
+watchdog

dtpyappframework-2.0/src/dtPyAppFramework/_version.txt

@@ -0,0 +1 @@
+2.0

{dtpyappframework-1.5.2 → dtpyappframework-2.0}/src/dtPyAppFramework/settings/__init__.py

@@ -177,7 +177,7 @@ class Settings(dict):
             value: Value to set.
             store_name (str, optional): Name of the store for persistent settings.
         """
-        self.secret_manager.set_secret(key, value, store_name)
+        self.secret_manager.set_persistent_setting(key, value)
 
     def __getattr__(self, key):
         """

{dtpyappframework-1.5.2 → dtpyappframework-2.0}/src/dtPyAppFramework/settings/secrets/__init__.py

@@ -153,6 +153,15 @@ class SecretsManager(object):
 
         return value
 
+    def set_persistent_setting(self, key, value):
+        for store in self.stores:
+            if 'User_Local_Store' == store.store_name:
+                if store.store_available and not store.store_read_only:
+                    store.set_persistent_setting(key, value)
+                else:
+                    logging.warning(f'Secrets Store {store.store_name} is either not available or is read only.')
+                break
+
     def set_secret(self, key, value, store_name='User_Local_Store'):
         """
         Set a secret in the specified secret store.

dtpyappframework-2.0/src/dtPyAppFramework/settings/secrets/keystore.py

@@ -0,0 +1,196 @@
+import os
+import json
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+from cryptography.hazmat.primitives.hmac import HMAC
+from cryptography.hazmat.primitives.hashes import SHA256
+from cryptography.hazmat.backends import default_backend
+from cryptography.fernet import Fernet
+import base64
+import logging
+
+class PasswordProtectedKeystoreWithHMAC:
+    """
+    PasswordProtectedKeystoreWithHMAC provides a mechanism to securely store key-value pairs
+    in a file. The data is protected using encryption and integrity is ensured by HMAC.
+
+    Methods:
+        __init__(keystore_path, password):
+            Initializes the keystore with the provided path and password.
+
+        _derive_key(salt):
+            Derives an encryption key from the password and salt using PBKDF2.
+
+        _generate_hmac(data, key):
+            Generates an HMAC for the given data using the derived key.
+
+        _verify_hmac(data, key, expected_hmac):
+            Verifies the HMAC for the given data against the expected HMAC.
+
+        _load_keystore():
+            Loads the keystore from the file, verifying its integrity and returning the stored data.
+
+        _save_keystore(data):
+            Saves the provided data to the keystore file, including the generated HMAC for integrity.
+
+        set(key, value):
+            Adds or updates a key-value pair in the keystore.
+
+        get(key):
+            Retrieves a value from the keystore by its key.
+
+        delete(key):
+            Deletes a key-value pair from the keystore.
+    """
+    def __init__(self, keystore_path, password):
+        self.keystore_path = keystore_path
+        self.password = password.encode()
+
+    def _derive_key(self, salt):
+        """
+        Args:
+            salt: A cryptographic salt used for deriving the key, which should be a byte sequence.
+
+        Returns:
+            A base64-encoded, url-safe byte sequence representing the derived cryptographic key.
+        """
+        kdf = PBKDF2HMAC(
+            algorithm=SHA256(),
+            length=32,
+            salt=salt,
+            iterations=100_000,
+            backend=default_backend()
+        )
+        return base64.urlsafe_b64encode(kdf.derive(self.password))
+
+    def _generate_hmac(self, data, key):
+        """
+        Args:
+            data: The data that needs to be protected with an HMAC.
+            key: The cryptographic key used for HMAC generation.
+        """
+        hmac = HMAC(key, SHA256(), backend=default_backend())
+        hmac.update(data)
+        return hmac.finalize()
+
+    def _verify_hmac(self, data, key, expected_hmac):
+        """
+        Args:
+            data: The data for which the HMAC is to be verified.
+            key: The secret key used for the HMAC generation.
+            expected_hmac: The HMAC value that is expected for the provided data and key combination.
+
+        Returns:
+            bool: True if the computed HMAC matches the expected HMAC, False otherwise.
+
+        """
+        hmac = HMAC(key, SHA256(), backend=default_backend())
+        hmac.update(data)
+        try:
+            hmac.verify(expected_hmac)
+            return True
+        except:
+            return False
+
+    def _load_keystore(self):
+        """
+        Loads and decrypts the keystore data from a specified file path.
+
+        If the keystore file exists, it reads the file content and extracts the salt,
+        encrypted data, and HMAC. The method then derives the key using the extracted
+        salt and verifies the HMAC to ensure data integrity. If the HMAC verification
+        fails, a ValueError is raised indicating potential file tampering. After successful
+        verification, the method decrypts the data using the derived key and
+        returns the decrypted JSON content. If the file does not exist, an empty
+        dictionary is returned.
+
+        Raises:
+            ValueError: If HMAC verification fails, indicating possible tampering.
+
+        Returns:
+            dict: The decrypted content of the keystore file as a dictionary, or an
+            empty dictionary if the keystore file does not exist.
+        """
+        if os.path.exists(self.keystore_path):
+            with open(self.keystore_path, 'rb') as file:
+                # Read the entire file content
+                file_content = file.read()
+
+                # Extract the salt, encrypted data, and HMAC
+                salt = file_content[:16]  # First 16 bytes
+                encrypted_data = file_content[16:-32]  # Middle bytes
+                stored_hmac = file_content[-32:]  # Last 32 bytes
+
+                # Derive the key and verify the HMAC
+                derived_key = self._derive_key(salt)
+                if not self._verify_hmac(salt + encrypted_data, derived_key, stored_hmac):
+                    raise ValueError("HMAC verification failed: File may have been tampered with.")
+
+                # Decrypt the data
+                cipher_suite = Fernet(derived_key)
+                decrypted_data = cipher_suite.decrypt(encrypted_data)
+                return json.loads(decrypted_data.decode())
+        return {}
+
+    def _save_keystore(self, data):
+        """
+        Args:
+            data: The data to be saved in the keystore, which will be encrypted and stored securely.
+        """
+        # Generate a random 16-byte salt
+        salt = os.urandom(16)
+
+        # Derive the key
+        derived_key = self._derive_key(salt)
+        cipher_suite = Fernet(derived_key)
+
+        # Encrypt the data
+        encrypted_data = cipher_suite.encrypt(json.dumps(data).encode())
+
+        # Generate the HMAC
+        hmac = self._generate_hmac(salt + encrypted_data, derived_key)
+
+        # Write the salt, encrypted data, and HMAC to the file
+        with open(self.keystore_path, 'wb') as file:
+            file.write(salt)
+            file.write(encrypted_data)
+            file.write(hmac)
+
+    def set(self, key, value):
+        """
+        Args:
+            key: The key to be stored in the keystore.
+            value: The value associated with the key to be stored.
+        """
+        keystore = self._load_keystore()
+        keystore[key] = value
+        self._save_keystore(keystore)
+        logging.debug(f"Key '{key}' stored successfully.")
+
+    def get(self, key):
+        """
+        Retrieves the value associated with the specified key from the keystore.
+
+        Args:
+            key: The key whose associated value is to be returned.
+
+        Returns:
+            The value corresponding to the specified key if it exists, otherwise None.
+        """
+        keystore = self._load_keystore()
+        logging.debug(f"Retrieving Key '{key}'")
+        return keystore.get(key)
+
+    def delete(self, key):
+        """
+        Deletes the specified key from the keystore if it exists.
+
+        Args:
+            key: The key to be deleted from the keystore.
+        """
+        keystore = self._load_keystore()
+        if key in keystore:
+            del keystore[key]
+            self._save_keystore(keystore)
+            logging.debug(f"Key '{key}' deleted successfully.")
+        else:
+            logging.debug(f"Key '{key}' not found in the keystore.")

{dtpyappframework-1.5.2 → dtpyappframework-2.0}/src/dtPyAppFramework/settings/secrets/local_secret_store.py

@@ -8,7 +8,9 @@ import pybase64
 from .secret_store import AbstractSecretStore, SecretsStoreException
 from itertools import cycle
 from ...misc import run_cmd
-import pykeystore
+
+from .keystore import PasswordProtectedKeystoreWithHMAC
+
 from base64 import urlsafe_b64encode
 
 
@@ -48,42 +50,23 @@ class LocalSecretStore(AbstractSecretStore):
             password (str): Password for the local secret store (default: None).
         """
         super().__init__(store_name, 'local', store_priority, application_settings)
-        self.store_path = os.path.join(root_store_path, f"{app_short_name}.keystore")
+        if os.path.exists(os.path.join(root_store_path, f"{app_short_name}.keystore")):
+            logging.warning(f'Old Keystore file "{os.path.join(root_store_path, f"{app_short_name}.keystore")}" is no longer supported.')
+        self.store_path = os.path.join(root_store_path, f"{app_short_name}.v2keystore")
 
         # If password is not provided, generate a unique password
         if password is None:
             password = self.__guid()
 
         try:
-            # If the store does not exist, initialize it
-            if not os.path.exists(self.store_path):
-                self.store = self.__initialise_secrets_store(password)
-
             # Try to load the existing store
-            self.store = pykeystore.KeyStoreEx.load(self.store_path, password)
+            self.store = PasswordProtectedKeystoreWithHMAC(self.store_path, password)
             self.store_available = True
             self.store_read_only = not self.__is_writeable()
             logging.info(f'Successfully opened Secrets Store: {self.store_path}')
         except Exception as ex:
             raise SecretsStoreException(f'Failed to open Secrets Store: {self.store_path}. Error: {str(ex)}')
 
-    def __initialise_secrets_store(self, password):
-        """
-        Initialize the secrets store if it doesn't exist.
-
-        Args:
-            password (str): Password for the local secret store.
-
-        Returns:
-            Initialized secrets store.
-        """
-        try:
-            store = pykeystore.KeyStoreEx.create(self.store_path, password)
-            return store
-        except Exception as ex:
-            logging.error(f'Failed to create Secrets Store.  Error: {str(ex)}')
-            raise ex
-
     def __guid(self):
         """
         Generate a unique identifier based on the machine and store path.
@@ -115,7 +98,7 @@ class LocalSecretStore(AbstractSecretStore):
         base += self.store_path
         key = re.sub("[^a-zA-Z]+", "", base)
         xored = ''.join(chr(ord(x) ^ ord(y)) for (x, y) in zip(base, cycle(key)))
-        return urlsafe_b64encode(pybase64.b64encode_as_string(xored.encode())[:32].encode())
+        return urlsafe_b64encode(pybase64.b64encode_as_string(xored.encode())[:32].encode()).decode()
 
     def get_secret(self, key, default_value=None):
         """
@@ -128,12 +111,20 @@ class LocalSecretStore(AbstractSecretStore):
         Returns:
             Secret value if found, else default_value.
         """
-        entry = self.store.getPassword(account=key)
+        entry = self.store.get(key=key)
         if not entry or entry == 'NONE':
             return default_value
 
         return entry
 
+    def set_persistent_setting(self, key, value):
+        if self.get_secret(key):
+            self.delete_secret(key)
+
+        self.store.set(key=key, value=value)
+        self.__save()
+
+
     def set_secret(self, key, value):
         """
         Set a secret in the local secret store.
@@ -145,7 +136,7 @@ class LocalSecretStore(AbstractSecretStore):
         if self.get_secret(key):
             self.delete_secret(key)
 
-        self.store.setPassword(account=key, password=value)
+        self.store.set(key=key, value=value)
         self.__save()
         index = self.get_index()
         if key not in index:
@@ -159,7 +150,7 @@ class LocalSecretStore(AbstractSecretStore):
         Args:
             key (str): Key of the secret.
         """
-        entry = self.store.setPassword(account=key, password='NONE')
+        self.store.delete(key=key)
         self.__save()
         index = self.get_index()
         while key in index:
@@ -168,7 +159,7 @@ class LocalSecretStore(AbstractSecretStore):
 
     def __set_index(self, index: list):
         logging.info(index)
-        self.store.setPassword(account=f'{self.store_name}.INDEX', password=json.dumps(index))
+        self.store.set(key=f'{self.store_name}.INDEX', value=json.dumps(index))
         self.__save()
 
     def get_index(self) -> list:
@@ -181,7 +172,8 @@ class LocalSecretStore(AbstractSecretStore):
 
     def __save(self):
         """Save the changes made to the local secret store."""
-        self.store.save(self.store_path, self.__guid())
+        self.store.set('sstore_save', 'true')
+        self.store.delete('sstore_save')
 
     def __is_writeable(self):
         try:

dtpyappframework-2.0/src/dtPyAppFramework/settings/settings_reader.py

@@ -0,0 +1,155 @@
+from watchdog.observers import Observer
+from watchdog.events import FileSystemEventHandler, FileSystemEvent
+import yaml
+import logging
+import os
+import hashlib
+
+class ConfigFileWatcher(FileSystemEventHandler):
+
+    def __init__(self, change_action, delete_action, watch_file, watch_folder):
+        self.change_action = change_action
+        self.delete_action = delete_action
+        self.watch_file = watch_file
+        self.watch_folder = watch_folder
+        self.watch_file_sha256 = self.calculate_sha256(os.path.join(self.watch_folder, self.watch_file))
+
+    def calculate_sha256(self, file_path):
+        sha256_hash = hashlib.sha256()
+        try:
+            with open(file_path, "rb") as f:
+                # Read and update hash in chunks of 4K
+                for byte_block in iter(lambda: f.read(4096), b""):
+                    sha256_hash.update(byte_block)
+            return sha256_hash.hexdigest()
+        except FileNotFoundError:
+            return "File not found."
+        except Exception as e:
+            return f"An error occurred: {str(e)}"
+
+    def process(self, event: FileSystemEvent):
+        """
+           event.event_type
+               'modified' | 'created' | 'moved' | 'deleted'
+           event.src_path
+               path to the modified file
+           """
+        if event.src_path.endswith(self.watch_file):
+            if event.event_type == 'deleted':
+                logging.warning(f'Config Watch File Deleted: {event.src_path}')
+                self.delete_action()
+            elif event.event_type == 'modified':
+                if self.calculate_sha256(event.src_path) != self.watch_file_sha256:
+                    logging.warning(f'Config Watch File Changed: {event.src_path}')
+                    self.watch_file_sha256 = self.calculate_sha256(event.src_path)
+                    self.change_action()
+            elif event.event_type == 'created':
+                logging.warning(f'Config Watch File Created: {event.src_path}')
+                self.watch_file_sha256 = self.calculate_sha256(event.src_path)
+                self.change_action()
+
+
+    def on_deleted(self, event: FileSystemEvent) -> None:
+        self.process(event)
+
+    def on_modified(self, event: FileSystemEvent):
+        self.process(event)
+
+    def on_created(self, event: FileSystemEvent):
+        self.process(event)
+
+
+
+class SettingsReader(dict):
+    """
+    A class for reading settings from a YAML file and accessing them using dot notation.
+
+    Attributes:
+        path (str): Path to the directory containing the settings YAML file.
+        priority (int): Priority of the settings reader.
+        settings_file (str): Full path to the settings YAML file.
+    """
+    CONFIG_FILE = "config.yaml"
+
+
+    def __init__(self, path: str, priority: int) -> None:
+        """
+        Initialize the SettingsReader.
+
+        Args:
+            path (str): Path to the directory containing the settings YAML file.
+            priority (int): Priority of the settings reader.
+        """
+        self.priority = priority
+        self.settings_file = os.path.join(path, self.CONFIG_FILE)
+
+        self.load_yaml_file()
+        self.observer = Observer()
+        event_handler = ConfigFileWatcher(change_action=self.load_yaml_file, delete_action=super().clear,
+                                          watch_file=self.CONFIG_FILE, watch_folder=path)
+        self.observer.schedule(event_handler, path, recursive=False)
+        self.observer.start()
+
+        super().__init__()
+
+    def load_yaml_file(self):
+        """
+        Load settings from the YAML file and update the dictionary.
+        """
+        if os.path.exists(self.settings_file):
+            try:
+                with open(self.settings_file, 'r', encoding='UTF-8') as file:
+                    super().clear()
+                    self.update(yaml.safe_load(file))
+                logging.info(f'Loaded settings file {self.settings_file}.')
+            except Exception as ex:
+                logging.error(f'Error reading in settings file {self.settings_file}. {str(ex)}')
+                print(f'Error reading in settings file {self.settings_file}. {str(ex)}')
+        else:
+            logging.warning(f'Settings file "{self.settings_file}" does not exist.')
+
+    def clear(self) -> None:
+        """
+        Clear method not implemented.
+        """
+        raise NotImplementedError
+
+    def popitem(self):
+        """
+        popitem method not implemented.
+        """
+        raise NotImplementedError
+
+    def __setitem__(self, k, v) -> None:
+        """
+        __setitem__ method not implemented.
+        """
+        raise NotImplementedError
+
+    def pop(self, __key):
+        """
+        pop method not implemented.
+        """
+        raise NotImplementedError
+
+    def __getitem__(self, key):
+        """
+        Get item from the dictionary using dot notation.
+
+        Args:
+            key (str): Key in dot notation.
+
+        Returns:
+            The value associated with the key.
+        """
+        keys = key.split('.')
+        if len(keys) == 1:
+            return dict.__getitem__(self, key)
+        else:
+            data = self.copy()
+            for key in keys:
+                if key in data:
+                    data = data[key]
+                else:
+                    return None
+            return data

{dtpyappframework-1.5.2 → dtpyappframework-2.0/src/dtPyAppFramework.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dtPyAppFramework
-Version: 1.5.2
+Version: 2.0
 Summary: A Python library for common features in application development.
 Author-email: Digital-Thought <dev@digital-thought.org>
 Maintainer-email: Digital-Thought <dev@digital-thought.org>
@@ -54,13 +54,13 @@ Requires-Dist: colorlog
 Requires-Dist: psutil
 Requires-Dist: pybase64
 Requires-Dist: boto3
-Requires-Dist: cryptography==39.0.2
+Requires-Dist: cryptography
 Requires-Dist: azure-identity
 Requires-Dist: azure-keyvault-secrets
-Requires-Dist: pykeystore
 Requires-Dist: pytest-mock
 Requires-Dist: pytest-watch
 Requires-Dist: pytest
+Requires-Dist: watchdog
 
 # dtPyAppFramework
 

{dtpyappframework-1.5.2 → dtpyappframework-2.0}/src/dtPyAppFramework.egg-info/SOURCES.txt

@@ -35,5 +35,8 @@ src/dtPyAppFramework/settings/settings_reader.py
 src/dtPyAppFramework/settings/secrets/__init__.py
 src/dtPyAppFramework/settings/secrets/aws_secret_store.py
 src/dtPyAppFramework/settings/secrets/azure_secret_store.py
+src/dtPyAppFramework/settings/secrets/keystore.py
 src/dtPyAppFramework/settings/secrets/local_secret_store.py
-src/dtPyAppFramework/settings/secrets/secret_store.py
+src/dtPyAppFramework/settings/secrets/secret_store.py
+tests/test_keystore.py
+tests/test_settings_reader.py

{dtpyappframework-1.5.2 → dtpyappframework-2.0}/src/dtPyAppFramework.egg-info/requires.txt

@@ -3,10 +3,10 @@ colorlog
 psutil
 pybase64
 boto3
-cryptography==39.0.2
+cryptography
 azure-identity
 azure-keyvault-secrets
-pykeystore
 pytest-mock
 pytest-watch
 pytest
+watchdog

dtpyappframework-2.0/tests/test_keystore.py

@@ -0,0 +1,70 @@
+import base64
+import json
+import os
+from unittest import mock
+
+import pytest
+from cryptography.fernet import Fernet
+from cryptography.hazmat.backends import default_backend
+from cryptography.hazmat.primitives.hashes import SHA256
+from cryptography.hazmat.primitives.hmac import HMAC
+from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
+# Import the class to test
+from dtPyAppFramework.settings.secrets.keystore import PasswordProtectedKeystoreWithHMAC
+
+# The path to a temporary file for testing purposes
+TEMP_FILE_PATH = "/tmp/test_keystore.db"
+
+
+def teardown_function(function):
+    if os.path.exists(TEMP_FILE_PATH):
+        os.remove(TEMP_FILE_PATH)
+
+
+@pytest.fixture
+def keystore():
+    return PasswordProtectedKeystoreWithHMAC(TEMP_FILE_PATH, 'test_password')
+
+
+def test_init(keystore):
+    assert keystore.keystore_path == TEMP_FILE_PATH
+    assert keystore.password == 'test_password'.encode()
+
+
+def test_derive_key(keystore):
+    salt = os.urandom(16)
+    key = keystore._derive_key(salt)
+    assert (isinstance(key, bytes))
+    assert (len(key) == 44)  # Length of base64 encoded 256-bit key
+
+
+def test_generate_hmac(keystore):
+    salt = os.urandom(16)
+    key = keystore._derive_key(salt)
+    data = os.urandom(16)
+    hmac = keystore._generate_hmac(data, key)
+    assert (isinstance(hmac, bytes))
+    assert (len(hmac) == 32)  # Length of SHA256 hash
+
+
+def test_verify_hmac(keystore):
+    salt = os.urandom(16)
+    key = keystore._derive_key(salt)
+    data = os.urandom(16)
+    hmac = keystore._generate_hmac(data, key)
+    assert keystore._verify_hmac(data, key, hmac) is True
+
+
+def test_save_and_load_keystore(keystore):
+    test_data = {"test_key": "test_value"}
+    keystore._save_keystore(test_data)
+    loaded_data = keystore._load_keystore()
+
+    assert loaded_data == test_data
+
+
+def test_set_get_delete_methods(keystore):
+    keystore.set("test_key", "test_value")
+    assert keystore.get("test_key") == "test_value"
+    keystore.delete("test_key")
+    assert keystore.get("test_key") is None

dtpyappframework-2.0/tests/test_settings_reader.py

@@ -0,0 +1,54 @@
+import os
+from unittest import mock
+
+import pytest
+from dtPyAppFramework.settings.settings_reader import SettingsReader
+
+
+# Test that __init__ sets the attributes correctly
+def test_init():
+    settings_reader = SettingsReader('/path/to/settings', 5)
+    assert settings_reader.priority == 5
+    assert settings_reader.settings_file == '/path/to/settings/config.yaml'
+
+
+# Test that load_yaml_file loads a YAML file correctly
+@mock.patch('yaml.safe_load', return_value={'key': 'value'})
+def test_load_yaml_file(mock_safe_load):
+    settings_reader = SettingsReader('/path/to/settings', 5)
+    settings_reader.load_yaml_file()
+    assert settings_reader.get('key') == 'value'
+
+
+# Test that __getitem__ can retrieve data correctly using dot notation
+def test_getitem():
+    settings_reader = SettingsReader('/path/to/settings', 5)
+
+    data = {
+        'key': 'value',
+        'nested': {
+            'key': 'nested value'
+        }
+    }
+
+    settings_reader.update(data)
+
+    assert settings_reader.__getitem__('nested.key') == 'nested value'
+    assert settings_reader.__getitem__('key') == 'value'
+
+
+# Test that methods that are not implemented raise a NotImplementedError
+def test_not_implemented_methods():
+    settings_reader = SettingsReader('/path/to/settings', 5)
+
+    with pytest.raises(NotImplementedError):
+        settings_reader.clear()
+
+    with pytest.raises(NotImplementedError):
+        settings_reader.popitem()
+
+    with pytest.raises(NotImplementedError):
+        settings_reader.__setitem__('key', 'value')
+
+    with pytest.raises(NotImplementedError):
+        settings_reader.pop('key')

dtpyappframework-1.5.2/src/dtPyAppFramework/_version.txt

@@ -1 +0,0 @@
-1.5.2

dtpyappframework-1.5.2/src/dtPyAppFramework/settings/settings_reader.py

@@ -1,88 +0,0 @@
-import json
-import yaml
-import logging
-import os
-
-class SettingsReader(dict):
-    """
-    A class for reading settings from a YAML file and accessing them using dot notation.
-
-    Attributes:
-        path (str): Path to the directory containing the settings YAML file.
-        priority (int): Priority of the settings reader.
-        settings_file (str): Full path to the settings YAML file.
-    """
-
-    def __init__(self, path: str, priority: int) -> None:
-        """
-        Initialize the SettingsReader.
-
-        Args:
-            path (str): Path to the directory containing the settings YAML file.
-            priority (int): Priority of the settings reader.
-        """
-        self.priority = priority
-        self.settings_file = os.path.join(path, "config.yaml")
-
-        if os.path.exists(self.settings_file):
-            self.load_yaml_file()
-
-        super().__init__()
-
-    def load_yaml_file(self):
-        """
-        Load settings from the YAML file and update the dictionary.
-        """
-        try:
-            with open(self.settings_file, 'r', encoding='UTF-8') as file:
-                self.update(yaml.safe_load(file))
-        except Exception as ex:
-            logging.error(f'Error reading in settings file {self.settings_file}. {str(ex)}')
-            print(f'Error reading in settings file {self.settings_file}. {str(ex)}')
-
-
-    def clear(self) -> None:
-        """
-        Clear method not implemented.
-        """
-        raise NotImplementedError
-
-    def popitem(self):
-        """
-        popitem method not implemented.
-        """
-        raise NotImplementedError
-
-    def __setitem__(self, k, v) -> None:
-        """
-        __setitem__ method not implemented.
-        """
-        raise NotImplementedError
-
-    def pop(self, __key):
-        """
-        pop method not implemented.
-        """
-        raise NotImplementedError
-
-    def __getitem__(self, key):
-        """
-        Get item from the dictionary using dot notation.
-
-        Args:
-            key (str): Key in dot notation.
-
-        Returns:
-            The value associated with the key.
-        """
-        keys = key.split('.')
-        if len(keys) == 1:
-            return dict.__getitem__(self, key)
-        else:
-            data = self.copy()
-            for key in keys:
-                if key in data:
-                    data = data[key]
-                else:
-                    return None
-            return data