dtPyAppFramework 2.0__tar.gz → 2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dtPyAppFramework
-Version: 2.0
+Version: 2.2
 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>

dtpyappframework-2.2/src/dtPyAppFramework/_version.txt

@@ -0,0 +1 @@
+2.2

{dtpyappframework-2.0 → dtpyappframework-2.2}/src/dtPyAppFramework/application.py

@@ -89,6 +89,9 @@ class AbstractApp(object):
         """
         raise NotImplementedError
 
+    def exiting(self):
+        raise NotImplementedError
+
     def __define_args(self, arg_parser: ArgumentParser):
         """
         Define command-line arguments based on application state.
@@ -116,6 +119,11 @@ class AbstractApp(object):
             arg_parser.add_argument('--name', action='store', type=str, required=True, help="Secret Name")
             arg_parser.add_argument('--value', action='store', type=str, required=True, help="Secret Value")
 
+    def exit(self):
+        self.exiting()
+        from dtPyAppFramework.settings import Settings
+        Settings().close()
+
     def run(self):
         """
         Run the application.
@@ -124,5 +132,6 @@ class AbstractApp(object):
         self.__define_args(arg_parser)
         self.process_manager = ProcessManager(description=self.description, version=self.version,
                                               short_name=self.short_name, full_name=self.full_name,
-                                              console_app=self.console_app, main_procedure=self.main)
+                                              console_app=self.console_app, main_procedure=self.main,
+                                              exit_procedure=self.exit)
         self.process_manager.initialise_application(arg_parser)

{dtpyappframework-2.0 → dtpyappframework-2.2}/src/dtPyAppFramework/process/__init__.py

@@ -45,7 +45,7 @@ class ProcessManager():
         stderr_txt_file (file): File object for capturing stderr to a text file.
     """
 
-    def __init__(self, description, version, short_name, full_name, console_app, main_procedure):
+    def __init__(self, description, version, short_name, full_name, console_app, main_procedure, exit_procedure=None):
         super().__init__()
         # Initialization of attributes
         self.description = description
@@ -59,11 +59,12 @@ class ProcessManager():
         self.resource_manager = None
         self.log_path = None
         self.main_procedure = main_procedure
+        self.exit_procedure = exit_procedure
         self.multiprocessing_manager = None
         self.stdout_txt_file = None
         self.stderr_txt_file = None
 
-    def __initialise_spawned_application__(self, parent_log_path, job_id, worker_id, job_name):
+    def __initialise_spawned_application__(self, parent_log_path, job_id, worker_id, job_name, pipe_registry):
         """
         Initialize a spawned instance of the application in a multiprocessing environment.
 
@@ -84,7 +85,7 @@ class ProcessManager():
                                                                spawned_process=True,
                                                                job_id=job_id, worker_id=worker_id,
                                                                parent_log_path=parent_log_path)
-                self.application_settings.init_settings_readers()
+                self.application_settings.init_settings_readers(pipe_registry=pipe_registry)
                 self.application_settings.secret_manager.load_cloud_stores()
 
                 self.__initialise_stdout_capt__()
@@ -151,6 +152,8 @@ class ProcessManager():
 
         except KeyboardInterrupt as kbi:
             logging.warning('(KeyboardInterrupt) Exiting application.')
+            if self.exit_procedure:
+                self.exit_procedure()
             if not self.console_app:
                 self.stdout_txt_file.close()
                 self.stderr_txt_file.close()
@@ -184,3 +187,6 @@ class ProcessManager():
         """
         self.load_config()
         self.main_procedure(args)
+
+        if self.exit_procedure:
+            self.exit_procedure()

{dtpyappframework-2.0 → dtpyappframework-2.2}/src/dtPyAppFramework/process/multiprocessing.py

@@ -1,6 +1,7 @@
 from ..decorators import singleton
 from multiprocessing import Process, Manager
 from ..paths import ApplicationPaths
+from dtPyAppFramework.settings import Settings
 
 import sys
 import os
@@ -25,7 +26,7 @@ def get_new_uuid():
 
 
 @singleton()
-class MultiProcessingManager():
+class MultiProcessingManager:
     """
     Singleton class for managing multiprocessing operations.
 
@@ -36,6 +37,7 @@ class MultiProcessingManager():
     def __init__(self):
         super().__init__()
         self.log_path = None
+        self.jobs = {}
 
     def set_log_path(self, log_path):
         """
@@ -46,6 +48,11 @@ class MultiProcessingManager():
         """
         self.log_path = log_path
 
+    def get_job(self, job_name):
+        if job_name not in self.jobs:
+            return None
+        return self.jobs[job_name]
+
     def new_multiprocessing_job(self, job_name, worker_count, target, args=(), kwargs={}):
         """
         Create a new multiprocessing job.
@@ -60,7 +67,9 @@ class MultiProcessingManager():
         Returns:
             MultiProcessingJob: An instance of MultiProcessingJob.
         """
-        return MultiProcessingJob(self.log_path, job_name, worker_count, target, args, kwargs)
+        job = MultiProcessingJob(self.log_path, job_name, worker_count, target, args, kwargs)
+        self.jobs[job_name] = job
+        return job
 
 
 class MultiProcessingJob():
@@ -94,8 +103,9 @@ class MultiProcessingJob():
         Start the worker processes for the job.
         """
         for x in range(self.worker_count):
-            worker = DtProcess(self.log_path, self.job_id, self.job_name, self.target, self.job_name, self.args,
-                               self.kwargs)
+            pipe_registry = Settings().secret_manager.local_secrets_store_manager.server_thread.pipe_registry
+            worker = DtProcess(self.log_path, self.job_id, self.job_name, self.target, self.job_name, pipe_registry,
+                               self.args, self.kwargs)
             worker.start()
             logging.info(f'Started Worker {worker.worker_id} for Job ID {self.job_id} ({self.job_name}).')
             self.workers.append(worker)
@@ -109,6 +119,8 @@ class MultiProcessingJob():
         logging.info(f'All Workers for Job ID {self.job_id} ({self.job_name}) ended.')
 
 
+
+
 class DtProcess(Process):
     """
     Custom multiprocessing Process class with additional attributes.
@@ -121,12 +133,14 @@ class DtProcess(Process):
         multi_processing_job (MultiProcessingJob): Reference to the parent MultiProcessingJob.
     """
 
-    def __init__(self, parent_log_path, job_id, job_name, target=None, name=None, args=(), kwargs={}):
+    def __init__(self, parent_log_path, job_id, job_name, target=None, name=None, pipe_registry=None,
+                 args=(), kwargs={}):
         self.worker_id = get_new_uuid()
         self.job_id = job_id
         self.job_name = job_name
         self.parent_log_path = parent_log_path
         self.multi_processing_job = None
+        self.pipe_registry = pipe_registry
         super(DtProcess, self).__init__(target=target, name=name, args=args, kwargs=kwargs)
 
     def set_parent(self, job):
@@ -144,8 +158,9 @@ class DtProcess(Process):
         """
         from . import ProcessManager
         ProcessManager().__initialise_spawned_application__(self.parent_log_path, self.job_id, self.worker_id,
-                                                            self.job_name)
+                                                            self.job_name, self.pipe_registry)
         print(f'Process ID = {os.getpid()}')
         print(f'worker_id {os.getpid()} = {self.worker_id}')
         print(f'job_id {os.getpid()} = {self.job_id}')
         super().run()
+        Settings().secret_manager.close()

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

@@ -36,12 +36,15 @@ class Settings(dict):
 
         self.settings_readers = []
         self.persistent_settings_stores = []
-        self.secret_manager = None
+        self.secret_manager: SecretsManager = None
         self.cloud_session_manager = None
 
         super().__init__()
 
-    def init_settings_readers(self):
+    def close(self):
+        self.secret_manager.close()
+
+    def init_settings_readers(self, pipe_registry=None):
         """
         Initialize settings readers.
         """
@@ -53,7 +56,7 @@ class Settings(dict):
         from ..cloud import CloudSessionManager
         self.cloud_session_manager = CloudSessionManager()
         self.secret_manager = SecretsManager(application_paths=self.application_paths, application_settings=self,
-                                             cloud_session_manager=self.cloud_session_manager)
+                                             cloud_session_manager=self.cloud_session_manager, pipe_registry=pipe_registry)
 
     def persist_settings(self, settings, scope):
         if scope == 'app':

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

@@ -4,6 +4,7 @@ from ...decorators import singleton
 from .local_secret_store import LocalSecretStore
 from .aws_secret_store import AWSSecretsStore
 from .azure_secret_store import AzureSecretsStore
+from .local_secret_stores_manager import LocalSecretStoresManager
 
 
 @singleton()
@@ -17,7 +18,7 @@ class SecretsManager(object):
         stores (list): A list to hold different secret stores.
     """
 
-    def __init__(self, application_paths=None, application_settings=None, cloud_session_manager=None) -> None:
+    def __init__(self, application_paths=None, application_settings=None, cloud_session_manager=None, pipe_registry=None) -> None:
         """
         Initialize the SecretsManager.
 
@@ -35,39 +36,16 @@ class SecretsManager(object):
         if not self.application_paths:
             self.application_paths = ApplicationPaths()
 
-        # Add local user secret store
-        self.stores.append(LocalSecretStore(store_name="User_Local_Store",
-                                            store_priority=-0,
-                                            root_store_path=self.application_paths.usr_data_root_path,
-                                            application_settings=self.application_settings,
-                                            app_short_name=self.application_paths.app_short_name))
-
-        try:
-            # Add local app secret store (if it exists)
-            self.stores.append(LocalSecretStore(store_name="App_Local_Store",
-                                                store_priority=1,
-                                                root_store_path=self.application_paths.app_data_root_path,
-                                                application_settings=self.application_settings,
-                                                app_short_name=self.application_paths.app_short_name))
-        except Exception as ex:
-            print(f'Skipping APP Local Secret Store. {ex}')
+        self.local_secrets_store_manager = LocalSecretStoresManager(application_paths, application_settings,
+                                                                    pipe_registry)
+        self.store_names.extend(self.local_secrets_store_manager.store_names)
 
-        # Sort stores based on priority
-        self._sort_stores()
+
+    def close(self):
+        self.local_secrets_store_manager.close()
 
     def get_local_stores_index(self):
-        _index = {"User_Local_Store": {}, "App_Local_Store": {}}
-        for key in _index:
-            store: LocalSecretStore = self.get_store(key)
-            try:
-                _index[key]['available'] = store.store_available
-                _index[key]['index'] = store.get_index()
-                _index[key]['read_only'] = store.store_read_only
-            except Exception as ex:
-                logging.error(str(ex))
-                _index[key]['available'] = False
-
-        return _index
+        return self.local_secrets_store_manager.get_local_stores_index()
 
     def _sort_stores(self):
         self.stores.sort(key=lambda x: x.store_priority)
@@ -134,18 +112,22 @@ class SecretsManager(object):
             store_name = elements[0]
             key = elements[1]
 
-        for store in self.stores:
-            if store_name and store_name == store.store_name:
-                if store.store_available:
-                    value = store.get_secret(key, None)
-                else:
-                    logging.error(f'Store {store.store_name} is not available to retrieve secret.')
-                break
-            elif not store_name:
-                if store.store_available:
-                    value = store.get_secret(key, None)
-                    if value:
-                        break
+        if store_name is None or store_name in ['User_Local_Store', 'App_Local_Store']:
+            value = self.local_secrets_store_manager.get_secret(key, value, store_name)
+
+        if not value:
+            for store in self.stores:
+                if store_name and store_name == store.store_name:
+                    if store.store_available:
+                        value = store.get_secret(key, None)
+                    else:
+                        logging.error(f'Store {store.store_name} is not available to retrieve secret.')
+                    break
+                elif not store_name:
+                    if store.store_available:
+                        value = store.get_secret(key, None)
+                        if value:
+                            break
 
         if not value:
             logging.debug(f'The Secret {key} was not found. Returning default value.')
@@ -173,6 +155,10 @@ class SecretsManager(object):
         """
         if not store_name:
             store_name = 'User_Local_Store'
+
+        if store_name in ['User_Local_Store', 'App_Local_Store']:
+            return self.local_secrets_store_manager.set_secret(key, value, store_name)
+
         for store in self.stores:
             if store_name == store.store_name:
                 if store.store_available and not store.store_read_only:

{dtpyappframework-2.0 → dtpyappframework-2.2}/src/dtPyAppFramework/settings/secrets/keystore.py

@@ -57,7 +57,7 @@ class PasswordProtectedKeystoreWithHMAC:
             algorithm=SHA256(),
             length=32,
             salt=salt,
-            iterations=100_000,
+            iterations=20_000,
             backend=default_backend()
         )
         return base64.urlsafe_b64encode(kdf.derive(self.password))

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

@@ -122,7 +122,6 @@ class LocalSecretStore(AbstractSecretStore):
             self.delete_secret(key)
 
         self.store.set(key=key, value=value)
-        self.__save()
 
 
     def set_secret(self, key, value):
@@ -137,7 +136,6 @@ class LocalSecretStore(AbstractSecretStore):
             self.delete_secret(key)
 
         self.store.set(key=key, value=value)
-        self.__save()
         index = self.get_index()
         if key not in index:
             index.append(key)
@@ -151,7 +149,6 @@ class LocalSecretStore(AbstractSecretStore):
             key (str): Key of the secret.
         """
         self.store.delete(key=key)
-        self.__save()
         index = self.get_index()
         while key in index:
             index.remove(key)
@@ -160,7 +157,6 @@ class LocalSecretStore(AbstractSecretStore):
     def __set_index(self, index: list):
         logging.info(index)
         self.store.set(key=f'{self.store_name}.INDEX', value=json.dumps(index))
-        self.__save()
 
     def get_index(self) -> list:
         index = self.get_secret(f'{self.store_name}.INDEX', None)
@@ -170,14 +166,10 @@ class LocalSecretStore(AbstractSecretStore):
 
         return json.loads(index)
 
-    def __save(self):
-        """Save the changes made to the local secret store."""
-        self.store.set('sstore_save', 'true')
-        self.store.delete('sstore_save')
-
     def __is_writeable(self):
         try:
-            self.__save()
+            self.store.set('sstore_save', 'true')
+            self.store.delete('sstore_save')
             return True
         except Exception as ex:
             logging.warning(str(ex))

dtpyappframework-2.2/src/dtPyAppFramework/settings/secrets/local_secret_stores_manager.py

@@ -0,0 +1,284 @@
+from ...paths import ApplicationPaths
+from .local_secret_store import LocalSecretStore
+import multiprocessing
+from threading import Thread
+import logging
+from enum import Enum
+
+class LocalSecretsManagerCommands(Enum):
+    CMD_GET_SECRET = 1
+    CMD_SET_SECRET = 2
+    CMD_SET_PERSISTENT_SECRET = 3
+    CMD_DELETE_SECRET = 4
+    CMD_STORE_AVAILABLE = 5
+    CMD_GET_INDEX = 6
+    CMD_STORE_READ_ONLY = 7
+    CMD_EXIT = 8
+    CMD_SHUTDOWN = 9
+    CMD_SUCCESS = 10
+    CMD_STORE_NAMES = 11
+
+class LocalSecretsManagerServer(Thread):
+
+    def __init__(self, application_paths, application_settings):
+        super().__init__(name='LocalSecretStoresManager_ServerThread')
+        self.application_paths = application_paths
+        self.application_settings = application_settings
+        self.stores = []
+        self.store_names = []
+        self.pipe_registry = multiprocessing.Queue()
+        self._load_stores()
+
+    def _load_stores(self):
+        if not self.application_paths:
+            self.application_paths = ApplicationPaths()
+
+        self.stores.append(LocalSecretStore(store_name="User_Local_Store",
+                                            store_priority=-0,
+                                            root_store_path=self.application_paths.usr_data_root_path,
+                                            application_settings=self.application_settings,
+                                            app_short_name=self.application_paths.app_short_name))
+
+        try:
+            # Add local app secret store (if it exists)
+            self.stores.append(LocalSecretStore(store_name="App_Local_Store",
+                                                store_priority=1,
+                                                root_store_path=self.application_paths.app_data_root_path,
+                                                application_settings=self.application_settings,
+                                                app_short_name=self.application_paths.app_short_name))
+        except Exception as ex:
+            print(f'Skipping APP Local Secret Store. {ex}')
+
+        for store in self.stores:
+            self.store_names.append(store.store_name)
+
+    def run(self):
+        running = True
+        while running:
+            conn = self.pipe_registry.get()  # Iterate over a copy to allow dynamic modifications
+            if conn.poll():  # Check if there is a message from this pipe
+                try:
+                    command, key, value, store_name = conn.recv()
+                    match command:
+                        case LocalSecretsManagerCommands.CMD_GET_SECRET:
+                            conn.send(self._get_secret(key, value, store_name))
+
+                        case LocalSecretsManagerCommands.CMD_SET_SECRET:
+                            conn.send(self._set_secret(key, value, store_name))
+
+                        case LocalSecretsManagerCommands.CMD_SET_PERSISTENT_SECRET:
+                            conn.send(self._set_persistent_setting(key, value))
+
+                        case LocalSecretsManagerCommands.CMD_DELETE_SECRET:
+                            conn.send(self._delete_secret(key, store_name))
+
+                        case LocalSecretsManagerCommands.CMD_STORE_AVAILABLE:
+                            conn.send(self._store_available(store_name))
+
+                        case LocalSecretsManagerCommands.CMD_GET_INDEX:
+                            conn.send(self._get_index(store_name))
+
+                        case LocalSecretsManagerCommands.CMD_STORE_READ_ONLY:
+                            conn.send(self._store_read_only(store_name))
+
+                        case LocalSecretsManagerCommands.CMD_STORE_NAMES:
+                            conn.send(self.store_names)
+
+                        case LocalSecretsManagerCommands.CMD_EXIT:
+                            conn.close()
+                            logging.warning('Closed Connection following EXIT request.')
+
+                        case LocalSecretsManagerCommands.CMD_SHUTDOWN:
+                            running = False
+
+                        case _:
+                            logging.error(
+                                f'Unrecognised Request: command = {command}, key = {key}, value = {value}, store_name = {store_name}')
+
+                    if not conn.closed:
+                        self.pipe_registry.put(conn)
+
+                except EOFError as ex:
+                    logging.exception(ex)
+
+            else:
+                self.pipe_registry.put(conn)
+
+        while not self.pipe_registry.empty():
+            pipe = self.pipe_registry.get()
+            pipe.close()
+        logging.warning('Closed All Connections following SHUTDOWN request.')
+        return
+
+    def _get_store(self, store_name):
+        """
+        Get a secret store by name.
+
+        Args:
+            store_name (str): Name of the secret store.
+
+        Returns:
+            Secret store instance if found, else None.
+        """
+        for store in self.stores:
+            if store_name == store.store_name:
+                return store
+        return None
+
+    def _store_available(self, store_name):
+        store: LocalSecretStore = self._get_store(store_name)
+        return store.store_available
+
+    def _get_index(self, store_name):
+        store: LocalSecretStore = self._get_store(store_name)
+        return store.get_index()
+
+    def _store_read_only(self, store_name):
+        store: LocalSecretStore = self._get_store(store_name)
+        return store.store_read_only
+
+    def _get_secret(self, key, default_value=None, store_name=None):
+        value = None
+        if len(key.split(".")) == 2 and key.split(".")[0] in self.store_names:
+            elements = key.split(".")
+            store_name = elements[0]
+            key = elements[1]
+
+        for store in self.stores:
+            if store_name and store_name == store.store_name:
+                if store.store_available:
+                    value = store.get_secret(key, None)
+                else:
+                    logging.error(f'Store {store.store_name} is not available to retrieve secret.')
+                break
+            elif not store_name:
+                if store.store_available:
+                    value = store.get_secret(key, None)
+                    if value:
+                        break
+
+        if not value:
+            logging.debug(f'The Secret {key} was not found. Returning default value.')
+            value = default_value
+
+        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
+        return LocalSecretsManagerCommands.CMD_SUCCESS
+
+    def _set_secret(self, key, value, store_name='User_Local_Store'):
+        if not store_name:
+            store_name = 'User_Local_Store'
+        for store in self.stores:
+            if store_name == store.store_name:
+                if store.store_available and not store.store_read_only:
+                    store.set_secret(key, value)
+                else:
+                    logging.warning(f'Secrets Store {store.store_name} is either not available or is read only.')
+                break
+        return LocalSecretsManagerCommands.CMD_SUCCESS
+
+    def _delete_secret(self, key, store_name='User_Local_Store'):
+        for store in self.stores:
+            if store_name and store_name == store.name():
+                value = store.delete_secret(key)
+                break
+
+        return LocalSecretsManagerCommands.CMD_SUCCESS
+
+
+class LocalSecretStoresManager:
+
+    def __init__(self, application_paths=None, application_settings=None, pipe_registry=None):
+        self.application_paths = application_paths
+        self.application_settings = application_settings
+        self.child_connection = None
+        self.server_thread = None
+        self.pipe_registry = pipe_registry
+
+        if self.pipe_registry is None and self.server_thread is None:
+            self.server_thread = LocalSecretsManagerServer(self.application_paths, self.application_settings)
+            self.server_thread.start()
+
+            control_pipe_parent, self.child_connection = multiprocessing.Pipe()
+            self.server_thread.pipe_registry.put(control_pipe_parent)
+
+        elif self.pipe_registry is not None:
+            logging.info('t')
+            parent_conn, self.child_connection = multiprocessing.Pipe()
+            logging.info('3')
+            self.pipe_registry = pipe_registry
+            self.pipe_registry.put(parent_conn)
+            logging.info('4')
+
+        else:
+            logging.error('Unexpected State for LocalSecretStoresManager')
+            raise Exception('Unexpected State for LocalSecretStoresManager')
+
+    def close(self):
+        if self.pipe_registry is None and self.server_thread is not None:
+            self.child_connection.send((LocalSecretsManagerCommands.CMD_SHUTDOWN, None, None, None))
+        elif self.pipe_registry is not None:
+            self.child_connection.send((LocalSecretsManagerCommands.CMD_EXIT, None, None, None))
+        else:
+            logging.error('Unexpected State for LocalSecretStoresManager')
+            raise Exception('Unexpected State for LocalSecretStoresManager')
+
+    def get_local_stores_index(self):
+        _index = {"User_Local_Store": {}, "App_Local_Store": {}}
+        for key in _index:
+            try:
+                _index[key]['available'] = self.store_available(key)
+                _index[key]['index'] = self.get_index(key)
+                _index[key]['read_only'] = self.store_read_only(key)
+            except Exception as ex:
+                logging.error(str(ex))
+                _index[key]['available'] = False
+
+        return _index
+
+    @property
+    def store_names(self):
+        self.child_connection.send((LocalSecretsManagerCommands.CMD_STORE_NAMES, None, None, None))
+        return self.child_connection.recv()
+
+    def store_available(self, store_name):
+        self.child_connection.send((LocalSecretsManagerCommands.CMD_STORE_AVAILABLE, None, None, store_name))
+        return self.child_connection.recv()
+
+    def get_index(self, store_name):
+        self.child_connection.send((LocalSecretsManagerCommands.CMD_GET_INDEX, None, None, store_name))
+        return self.child_connection.recv()
+
+    def store_read_only(self, store_name):
+        self.child_connection.send((LocalSecretsManagerCommands.CMD_STORE_READ_ONLY, None, None, store_name))
+        return self.child_connection.recv()
+
+    def get_secret(self, key, default_value=None, store_name=None):
+        self.child_connection.send((LocalSecretsManagerCommands.CMD_GET_SECRET, key, default_value, store_name))
+        return self.child_connection.recv()
+
+    def set_persistent_setting(self, key, value):
+        self.child_connection.send((LocalSecretsManagerCommands.CMD_SET_PERSISTENT_SECRET, key, value, None))
+        resp = self.child_connection.recv()
+        if resp != LocalSecretsManagerCommands.CMD_SUCCESS:
+            logging.error(resp)
+
+    def set_secret(self, key, value, store_name='User_Local_Store'):
+        self.child_connection.send((LocalSecretsManagerCommands.CMD_SET_SECRET, key, value, store_name))
+        resp = self.child_connection.recv()
+        if resp != LocalSecretsManagerCommands.CMD_SUCCESS:
+            logging.error(resp)
+
+    def delete_secret(self, key, store_name='User_Local_Store'):
+        self.child_connection.send((LocalSecretsManagerCommands.CMD_DELETE_SECRET, key, store_name))
+        resp = self.child_connection.recv()
+        if resp != LocalSecretsManagerCommands.CMD_SUCCESS:
+            logging.error(resp)

{dtpyappframework-2.0 → dtpyappframework-2.2}/src/dtPyAppFramework/settings/settings_reader.py

@@ -39,9 +39,11 @@ class ConfigFileWatcher(FileSystemEventHandler):
                 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)
+                new_sha256 = self.calculate_sha256(event.src_path)
+                if new_sha256 != self.watch_file_sha256:
+                    logging.warning(f'Config Watch File Changed: {event.src_path} - WAS: {self.watch_file_sha256},'
+                                    f' NOW: {new_sha256}')
+                    self.watch_file_sha256 = new_sha256
                     self.change_action()
             elif event.event_type == 'created':
                 logging.warning(f'Config Watch File Created: {event.src_path}')
@@ -88,7 +90,8 @@ class SettingsReader(dict):
         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()
+        if os.path.exists(path):
+            self.observer.start()
 
         super().__init__()
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dtPyAppFramework
-Version: 2.0
+Version: 2.2
 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>

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

@@ -37,6 +37,7 @@ 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/local_secret_stores_manager.py
 src/dtPyAppFramework/settings/secrets/secret_store.py
 tests/test_keystore.py
 tests/test_settings_reader.py

dtpyappframework-2.0/src/dtPyAppFramework/_version.txt

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