aneSettings 2025.9.0__tar.gz

anesettings-2025.9.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 - Cybernetic Innovations
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

anesettings-2025.9.0/PKG-INFO

@@ -0,0 +1,202 @@
+Metadata-Version: 2.4
+Name: aneSettings
+Version: 2025.9.0
+Summary: High-performance secure core framework for scalable, reliable applications
+Author-email: Cybernetic Innovations <github@cyberneticinnovations.com>
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyYAML~=6.0.2
+Requires-Dist: cryptography~=45.0.3
+Requires-Dist: loguru~=0.7.3
+Requires-Dist: pydantic~=2.11.5
+Dynamic: license-file
+
+
+# aneSettings
+
+aneSettings is a framework for developing scalable applications. It offers a set of core libraries and utilities to streamline the development workflow, enforce security best practices, and improve code maintainability. By supporting modern programming paradigms, it allows developers to build robust and efficient solutions with reduced overhead.
+
+### Key Features:
+- Security-First Approach: Built-in security measures to prevent common vulnerabilities.
+- Scalability: Optimized to handle high loads and large-scale applications.
+- Modularity: Highly modular architecture, allowing seamless integration and customization.
+- Ease of Use: Developer-friendly APIs and comprehensive documentation.
+
+### Goals:
+- Accelerate development time while maintaining high code quality.
+- Provide a flexible foundation to meet diverse application needs.
+- Ensure application security without compromising performance.
+
+---
+
+### Core Components:
+- **ConfigSettings**: Handles configuration and settings management
+- **CustomLogging**: Provides customized logging functionality
+- **Encryption**: Offers encryption-related utilities
+- **ProjectRoot**: Manages project root detection and path resolution
+
+---
+
+### **_ConfigSettings:_**
+
+```python
+# Basic Logging and Config Settings
+from aneSettings import logger, config
+
+# Constants
+FORMAT_PADDING = 25
+SEPARATOR_LINE = "-" * 150
+
+
+def log_sorted_settings(system_settings):
+    """Logs the key-value pairs of sorted settings."""
+    for setting_name, setting_value in system_settings:
+        logger.info(f'{setting_name:>{FORMAT_PADDING}}: {setting_value}')
+
+
+if __name__ == '__main__':
+    # -------------------------------------------------------------------------------------------------
+    # Example of viewing and sorting configuration settings
+    # -------------------------------------------------------------------------------------------------
+    logger.info(SEPARATOR_LINE)
+    sorted_settings = sorted(config)
+    log_sorted_settings(sorted_settings)
+```
+
+#### **_output_**
+
+```shell
+aneSettings | INFO     | ------------------------------------------------------------------------------------------------------------------------------------------------------
+aneSettings | INFO     |               ENVIRONMENT: Local
+aneSettings | INFO     |                    FN_KEY: pit...-iM2c=
+aneSettings | INFO     |               LOG_APPNAME: aneSettings
+aneSettings | INFO     |                LOG_FORMAT: {extra[app]} | <level>{level: <8}</level> | <cyan><level>{message}</level></cyan>
+aneSettings | INFO     |                 LOG_LEVEL: DEBUG
+aneSettings | INFO     |            MSSQL_DATABASE: {default_database}
+aneSettings | INFO     |            MSSQL_HOSTNAME: {hostname}
+aneSettings | INFO     |            MSSQL_PASSWORD: {password}
+aneSettings | INFO     |                MSSQL_PORT: {port}
+aneSettings | INFO     |               MSSQL_TRUST: {trust}
+aneSettings | INFO     |            MSSQL_USERNAME: {username}
+aneSettings | INFO     |              PROJECT_ROOT: /{project_root}/aneSettings
+aneSettings | INFO     |              VERSION_CORE: 2025.9.0
+```
+
+---
+
+### **_Encryption:_**
+
+```python
+# Basic Logging and Encryption
+from aneSettings import logger, encryption_service
+
+# Constants
+FORMAT_PADDING = 25
+SEPARATOR_LINE = "-" * 150
+
+
+def log_formatted(key, value):
+    """Helper to standardize log output."""
+    logger.info(f'{key:>{FORMAT_PADDING}}: {value}')
+
+
+if __name__ == '__main__':
+    # -------------------------------------------------------------------------------------------------
+    # Example of Encryption Usage
+    # -------------------------------------------------------------------------------------------------
+
+    # Data: set and show values
+    logger.info(SEPARATOR_LINE)
+    secret_data = "Sensitive Information"
+    log_formatted(key="Data", value=secret_data)
+    encryption_key = encryption_service.key.decode()
+    log_formatted(key="Key", value=encryption_key)
+
+    # Encryption: encrypt and decrypt
+    logger.info(SEPARATOR_LINE)
+    encrypted = encryption_service.encrypt(secret_data)
+    log_formatted(key="Encryption successful", value=f"{encrypted != secret_data} - {encrypted.decode()}")
+
+    decrypted = encryption_service.decrypt(encrypted)
+    log_formatted(key="Decryption successful", value=f"{decrypted == secret_data} - {decrypted}")
+
+    # Base64: encode and decode
+    logger.info(SEPARATOR_LINE)
+    b64_encoded = encryption_service.base64_encode(secret_data)
+    log_formatted(key="Encode successful", value=f"{b64_encoded != secret_data} - {b64_encoded}")
+
+    b64_decoded = encryption_service.base64_decode(b64_encoded)
+    log_formatted(key="Decode successful", value=f"{b64_decoded == secret_data} - {b64_decoded}")
+
+    # Generate a new key to replace the one in .env.settings `fn_key`
+    logger.info(SEPARATOR_LINE)
+    new_fn_key = encryption_service.generate_fernet_key().decode()
+    log_formatted(key="New fn_key", value=f"{new_fn_key}")
+    log_formatted(key="", value="Use this key to replace the one in .env.settings `fn_key`")
+
+    logger.info(SEPARATOR_LINE)
+```
+
+#### **_output_**
+
+```shell
+aneSettings | INFO     | ------------------------------------------------------------------------------------------------------------------------------------------------------
+aneSettings | INFO     |                      Data: Sensitive Information
+aneSettings | INFO     |                       Key: pitANnjVW1OX2LuVqrWw1H2b69wCewmdARQzr6-iM2c=
+aneSettings | INFO     | ------------------------------------------------------------------------------------------------------------------------------------------------------
+aneSettings | INFO     |     Encryption successful: True - gAAAAABox0DLjm7IOmFNRio8FYnp5tLVtMqPFpx5qFbbeot_jIUNah8XqLqHhPNmvaw1HpIBe0ebsna7ou8BrVnQ9erv6Fr1VK_O7PC3xDDXQXSEnyA2WhE=
+aneSettings | INFO     |     Decryption successful: True - Sensitive Information
+aneSettings | INFO     | ------------------------------------------------------------------------------------------------------------------------------------------------------
+aneSettings | INFO     |         Encode successful: True - U2Vuc2l0aXZlIEluZm9ybWF0aW9u
+aneSettings | INFO     |         Decode successful: True - Sensitive Information
+aneSettings | INFO     | ------------------------------------------------------------------------------------------------------------------------------------------------------
+aneSettings | INFO     |                New fn_key: RAl2XHZUwXQyZwXdzwVWJGKDDSwyJluh41De9KHw9oI=
+aneSettings | INFO     |                          : Use this key to replace the one in .env.settings `fn_key`
+```
+
+---
+
+### **_ProjectRoot:_**
+
+```python
+# Basic Logging and Project Path Operations
+from aneSettings import logger, project_root
+
+# Constants
+FORMAT_PADDING = 25
+SEPARATOR_LINE = "-" * 150
+
+
+def log_formatted(key, value):
+    """Helper to standardize log output."""
+    logger.info(f'{key:>{FORMAT_PADDING}}: {value}')
+
+
+if __name__ == "__main__":
+    # -------------------------------------------------------------------------------------------------
+    # Example of Project Path Operations
+    # -------------------------------------------------------------------------------------------------
+
+    # Get project-related paths
+    root_path = project_root
+    config_path = project_root / "config"
+    data_path = project_root / "data"
+
+    logger.info(SEPARATOR_LINE)
+    log_formatted(key="Project root", value=root_path)
+    log_formatted(key="Config path", value=config_path)
+    log_formatted(key="Data path", value=data_path)
+    logger.info(SEPARATOR_LINE)
+```
+
+#### **_output_**
+
+```shell
+aneSettings | INFO     | ------------------------------------------------------------------------------------------------------------------------------------------------------
+aneSettings | INFO     |              Project root: {project_root}
+aneSettings | INFO     |               Config path: {project_root}/config
+aneSettings | INFO     |                 Data path: {project_root}/data
+aneSettings | INFO     | ------------------------------------------------------------------------------------------------------------------------------------------------------
+```

anesettings-2025.9.0/ReadMe.md

@@ -0,0 +1,187 @@
+
+# aneSettings
+
+aneSettings is a framework for developing scalable applications. It offers a set of core libraries and utilities to streamline the development workflow, enforce security best practices, and improve code maintainability. By supporting modern programming paradigms, it allows developers to build robust and efficient solutions with reduced overhead.
+
+### Key Features:
+- Security-First Approach: Built-in security measures to prevent common vulnerabilities.
+- Scalability: Optimized to handle high loads and large-scale applications.
+- Modularity: Highly modular architecture, allowing seamless integration and customization.
+- Ease of Use: Developer-friendly APIs and comprehensive documentation.
+
+### Goals:
+- Accelerate development time while maintaining high code quality.
+- Provide a flexible foundation to meet diverse application needs.
+- Ensure application security without compromising performance.
+
+---
+
+### Core Components:
+- **ConfigSettings**: Handles configuration and settings management
+- **CustomLogging**: Provides customized logging functionality
+- **Encryption**: Offers encryption-related utilities
+- **ProjectRoot**: Manages project root detection and path resolution
+
+---
+
+### **_ConfigSettings:_**
+
+```python
+# Basic Logging and Config Settings
+from aneSettings import logger, config
+
+# Constants
+FORMAT_PADDING = 25
+SEPARATOR_LINE = "-" * 150
+
+
+def log_sorted_settings(system_settings):
+    """Logs the key-value pairs of sorted settings."""
+    for setting_name, setting_value in system_settings:
+        logger.info(f'{setting_name:>{FORMAT_PADDING}}: {setting_value}')
+
+
+if __name__ == '__main__':
+    # -------------------------------------------------------------------------------------------------
+    # Example of viewing and sorting configuration settings
+    # -------------------------------------------------------------------------------------------------
+    logger.info(SEPARATOR_LINE)
+    sorted_settings = sorted(config)
+    log_sorted_settings(sorted_settings)
+```
+
+#### **_output_**
+
+```shell
+aneSettings | INFO     | ------------------------------------------------------------------------------------------------------------------------------------------------------
+aneSettings | INFO     |               ENVIRONMENT: Local
+aneSettings | INFO     |                    FN_KEY: pit...-iM2c=
+aneSettings | INFO     |               LOG_APPNAME: aneSettings
+aneSettings | INFO     |                LOG_FORMAT: {extra[app]} | <level>{level: <8}</level> | <cyan><level>{message}</level></cyan>
+aneSettings | INFO     |                 LOG_LEVEL: DEBUG
+aneSettings | INFO     |            MSSQL_DATABASE: {default_database}
+aneSettings | INFO     |            MSSQL_HOSTNAME: {hostname}
+aneSettings | INFO     |            MSSQL_PASSWORD: {password}
+aneSettings | INFO     |                MSSQL_PORT: {port}
+aneSettings | INFO     |               MSSQL_TRUST: {trust}
+aneSettings | INFO     |            MSSQL_USERNAME: {username}
+aneSettings | INFO     |              PROJECT_ROOT: /{project_root}/aneSettings
+aneSettings | INFO     |              VERSION_CORE: 2025.9.0
+```
+
+---
+
+### **_Encryption:_**
+
+```python
+# Basic Logging and Encryption
+from aneSettings import logger, encryption_service
+
+# Constants
+FORMAT_PADDING = 25
+SEPARATOR_LINE = "-" * 150
+
+
+def log_formatted(key, value):
+    """Helper to standardize log output."""
+    logger.info(f'{key:>{FORMAT_PADDING}}: {value}')
+
+
+if __name__ == '__main__':
+    # -------------------------------------------------------------------------------------------------
+    # Example of Encryption Usage
+    # -------------------------------------------------------------------------------------------------
+
+    # Data: set and show values
+    logger.info(SEPARATOR_LINE)
+    secret_data = "Sensitive Information"
+    log_formatted(key="Data", value=secret_data)
+    encryption_key = encryption_service.key.decode()
+    log_formatted(key="Key", value=encryption_key)
+
+    # Encryption: encrypt and decrypt
+    logger.info(SEPARATOR_LINE)
+    encrypted = encryption_service.encrypt(secret_data)
+    log_formatted(key="Encryption successful", value=f"{encrypted != secret_data} - {encrypted.decode()}")
+
+    decrypted = encryption_service.decrypt(encrypted)
+    log_formatted(key="Decryption successful", value=f"{decrypted == secret_data} - {decrypted}")
+
+    # Base64: encode and decode
+    logger.info(SEPARATOR_LINE)
+    b64_encoded = encryption_service.base64_encode(secret_data)
+    log_formatted(key="Encode successful", value=f"{b64_encoded != secret_data} - {b64_encoded}")
+
+    b64_decoded = encryption_service.base64_decode(b64_encoded)
+    log_formatted(key="Decode successful", value=f"{b64_decoded == secret_data} - {b64_decoded}")
+
+    # Generate a new key to replace the one in .env.settings `fn_key`
+    logger.info(SEPARATOR_LINE)
+    new_fn_key = encryption_service.generate_fernet_key().decode()
+    log_formatted(key="New fn_key", value=f"{new_fn_key}")
+    log_formatted(key="", value="Use this key to replace the one in .env.settings `fn_key`")
+
+    logger.info(SEPARATOR_LINE)
+```
+
+#### **_output_**
+
+```shell
+aneSettings | INFO     | ------------------------------------------------------------------------------------------------------------------------------------------------------
+aneSettings | INFO     |                      Data: Sensitive Information
+aneSettings | INFO     |                       Key: pitANnjVW1OX2LuVqrWw1H2b69wCewmdARQzr6-iM2c=
+aneSettings | INFO     | ------------------------------------------------------------------------------------------------------------------------------------------------------
+aneSettings | INFO     |     Encryption successful: True - gAAAAABox0DLjm7IOmFNRio8FYnp5tLVtMqPFpx5qFbbeot_jIUNah8XqLqHhPNmvaw1HpIBe0ebsna7ou8BrVnQ9erv6Fr1VK_O7PC3xDDXQXSEnyA2WhE=
+aneSettings | INFO     |     Decryption successful: True - Sensitive Information
+aneSettings | INFO     | ------------------------------------------------------------------------------------------------------------------------------------------------------
+aneSettings | INFO     |         Encode successful: True - U2Vuc2l0aXZlIEluZm9ybWF0aW9u
+aneSettings | INFO     |         Decode successful: True - Sensitive Information
+aneSettings | INFO     | ------------------------------------------------------------------------------------------------------------------------------------------------------
+aneSettings | INFO     |                New fn_key: RAl2XHZUwXQyZwXdzwVWJGKDDSwyJluh41De9KHw9oI=
+aneSettings | INFO     |                          : Use this key to replace the one in .env.settings `fn_key`
+```
+
+---
+
+### **_ProjectRoot:_**
+
+```python
+# Basic Logging and Project Path Operations
+from aneSettings import logger, project_root
+
+# Constants
+FORMAT_PADDING = 25
+SEPARATOR_LINE = "-" * 150
+
+
+def log_formatted(key, value):
+    """Helper to standardize log output."""
+    logger.info(f'{key:>{FORMAT_PADDING}}: {value}')
+
+
+if __name__ == "__main__":
+    # -------------------------------------------------------------------------------------------------
+    # Example of Project Path Operations
+    # -------------------------------------------------------------------------------------------------
+
+    # Get project-related paths
+    root_path = project_root
+    config_path = project_root / "config"
+    data_path = project_root / "data"
+
+    logger.info(SEPARATOR_LINE)
+    log_formatted(key="Project root", value=root_path)
+    log_formatted(key="Config path", value=config_path)
+    log_formatted(key="Data path", value=data_path)
+    logger.info(SEPARATOR_LINE)
+```
+
+#### **_output_**
+
+```shell
+aneSettings | INFO     | ------------------------------------------------------------------------------------------------------------------------------------------------------
+aneSettings | INFO     |              Project root: {project_root}
+aneSettings | INFO     |               Config path: {project_root}/config
+aneSettings | INFO     |                 Data path: {project_root}/data
+aneSettings | INFO     | ------------------------------------------------------------------------------------------------------------------------------------------------------
+```

anesettings-2025.9.0/aneSettings/ConfigSettings.py

@@ -0,0 +1,245 @@
+import os
+import re
+import json
+import yaml
+
+from typing import Any
+from string import Template
+from pydantic.v1 import BaseSettings, Extra
+from pydantic.v1.env_settings import SettingsSourceCallable
+from .templates import ConfigSettings
+from .ProjectRoot import project_root
+from .__about__ import __version__
+
+# Constants
+ENV_FILE_SETTINGS = ".env.settings"
+ENV_FILE_SECRETS = ".env.secrets"
+DEFAULT_CONFIG_PATH = os.path.join(project_root(), "app")
+DEFAULT_SECRET_PATH = os.path.join(DEFAULT_CONFIG_PATH, "secrets")
+VALIDATION_RULES = {
+    "log_level": "ERROR",
+    "log_appname": "ERROR",
+}
+
+# Constant for an encryption key
+FN_KEY = "Z46GMhKyW9rHU8c2T0296Zgr153HSIPD5mo3-faiHdQ="
+
+CONFIG_KEY_PATTERN = re.compile(r"^[^#].+=[\"|\']*.*[\"|\']*$")  # Regex to match key-value pairs
+
+
+class ConfigManager:
+    """
+    Manages configuration settings, ensuring directories and files are set up properly while
+    validating and loading configuration data. Designed to handle and validate application
+    settings and secrets stored in files.
+
+    This class provides methods for loading configurations from files, managing directories,
+    and validating configurations based on predefined rules. It ensures that the required
+    directory structures and default configurations are initialized, with support for
+    overwriting these defaults by loading external configuration files.
+
+    :ivar parameters: Stores key-value pairs loaded from configuration files.
+    :type parameters: dict
+    :ivar validation_rules: Defines required configuration keys and their validation levels.
+    :type validation_rules: dict
+    :ivar errors: Tracks any errors or missing required keys during validation.
+    :type errors: dict
+    :ivar error_occurred: Indicates whether an error state exists in the configuration.
+    :type error_occurred: bool
+    :ivar config_dir: Path to the directory where configuration files are stored.
+    :type config_dir: str
+    :ivar secret_dir: Path to the directory where secret files are stored.
+    :type secret_dir: str
+    """
+
+    def __init__(self, validation_rules=None, config_path=DEFAULT_CONFIG_PATH, secret_path=DEFAULT_SECRET_PATH):
+        self.parameters: dict[str, str] = {}
+        self.validation_rules: dict[str, str] = validation_rules or {}
+        self.errors: dict[str, str] = {}
+        self.error_occurred: bool = False
+        self.config_dir: str = config_path
+        self.secret_dir: str = secret_path
+
+        self._setup_directories_and_configs()
+
+    def _setup_directories_and_configs(self):
+        """
+        Sets up the necessary directories and configuration files required for the application
+        to run. This includes ensuring that the directories exist, initializing necessary
+        configuration files with default values if they do not exist, and loading configurations
+        from these files.
+
+        Supported directories include the configuration directory and the secret directory.
+
+        The method also ensures environmental and secret configuration files exist by default
+        and reads configuration values from them.
+
+        :raises FileNotFoundError: If a necessary directory or file cannot be found.
+        """
+        self._ensure_directory(self.config_dir)
+        self._ensure_directory(self.secret_dir)
+        # self._initialize_file(os.path.join(self.config_dir, ENV_FILE_SETTINGS),
+        #                       Template(ConfigSettings.DEFAULT_ENV_SETTINGS).safe_substitute(fn_key=Fernet.generate_key().decode()))
+        self._initialize_file(os.path.join(self.config_dir, ENV_FILE_SETTINGS),
+                              Template(ConfigSettings.DEFAULT_ENV_SETTINGS).safe_substitute(fn_key='l911qB1keWvIykhvswzdKCQbr6h35Cabu8OeckOUbP4='))
+        self.load_configuration(os.path.join(self.config_dir, ENV_FILE_SETTINGS))
+
+        secrets_file = os.path.join(self.secret_dir, ENV_FILE_SECRETS)
+        self._initialize_file(secrets_file, ConfigSettings.DEFAULT_ENV_SECRET_SETTINGS)
+
+        if os.path.exists(secrets_file):
+            self.load_configuration(secrets_file)
+
+        # keys_file = os.path.join(self.secret_dir, KEYS_FILE_SECRETS)
+        # self._initialize_file(keys_file, Keys.create_default_keys())
+
+    @staticmethod
+    def _ensure_directory(path: str):
+        """
+        Ensures that the specified directory exists. If the directory does not exist,
+        it will be created. If it already exists, no action will be taken.
+
+        :param path: The directory path to ensure exists.
+        :type path: str
+        :return: None
+        """
+        os.makedirs(path, exist_ok=True)
+
+    @staticmethod
+    def _initialize_file(filepath: str, default_content: str = ""):
+        """
+        Initializes a file at the specified filepath. If the file does not already exist,
+        it creates the file and optionally writes the provided default content to it.
+
+        :param filepath: The path to the file to be initialized.
+        :type filepath: str
+        :param default_content: The content to write to the file if it is created.
+                                Defaults to an empty string.
+        :type default_content: str, optional
+        """
+        if not os.path.exists(filepath):
+            with open(filepath, "w") as file:
+                file.write(default_content)
+
+    def load_configuration(self, filename: str):
+        """
+        Loads configuration parameters from a specified file. The function reads the file line-by-line,
+        searching for configuration keys matching a predefined pattern. If a valid key-value pair is
+        found, it is parsed and added to the `parameters` dictionary of the instance. This allows dynamic
+        configuration loading from external files.
+
+        :param filename: The path to the configuration file to read.
+        :type filename: str
+        :return: None
+        """
+        with open(filename, "r") as file:
+            for line in file:
+                if CONFIG_KEY_PATTERN.search(line):
+                    key, value = self._parse_line(line)
+                    self.parameters[key] = value
+
+    @staticmethod
+    def _parse_line(line: str) -> tuple[str, str]:
+        """
+        Parses a configuration line, extracting a key-value pair by removing comments and cleaning whitespace and
+        quotes. The method ensures that the key is converted to uppercase for uniformity.
+
+        :param line: A string containing a configuration line, which may contain a key-value pair and comments.
+        :type line: str
+
+        :return: A tuple containing the extracted key (in uppercase) and cleaned value.
+        :rtype: tuple[str, str]
+        """
+        key_value = line.split("#", 1)[0].strip()  # Remove comments
+        key, value = key_value.split("=", 1)
+        return key.strip().upper(), value.strip().strip('"\'')  # Cleanup quotes
+
+    def validate_configuration(self):
+        """
+        Validates the configuration parameters against the defined validation rules and
+        determines whether any errors have occurred. Missing parameters are identified,
+        and detailed error messages are generated for each missing parameter according
+        to its required validation level.
+
+        :raises KeyError: if required, parameters are not uppercased in the validation rules.
+
+        :return: None
+        """
+        self.errors = {
+            param.upper(): json.dumps({
+                "settingRequired": {
+                    "details": f"'{param}' is missing.",
+                    "level": level,
+                }
+            })
+            for param, level in self.validation_rules.items()
+            if param.upper() not in self.parameters
+        }
+        self.error_occurred = any("ERROR" in error.upper() for error in self.errors.values())
+
+
+class Settings(BaseSettings):
+    """
+    Manages application settings and configurations, enabling the retrieval and
+    management of environment variables and project-specific attributes. This
+    class serves as a centralized configuration handler to ensure consistent
+    and systematic access to application settings.
+    """
+    VERSION_CORE: str = __version__
+    FN_KEY: str = os.getenv("FN_KEY", FN_KEY)
+    PROJECT_ROOT: str = f'{project_root()}'
+
+    class Config:
+        extra = Extra.allow
+        env_prefix = "medium_"
+
+        @classmethod
+        def customise_sources(
+                cls,
+                init_settings: SettingsSourceCallable,
+                env_settings: SettingsSourceCallable,
+                file_secret_settings: SettingsSourceCallable,
+        ) -> tuple[SettingsSourceCallable, ...]:
+            """
+            Customizes and overrides the default sequence of settings sources for loading
+            configuration values. Takes three callable sources as input—`init_settings`,
+            `env_settings`, and `file_secret_settings`—and allows users to specify their
+            custom sequence of sources to be applied.
+
+            :param init_settings: Initial callable source for fetching configuration values.
+            :param env_settings: Callable source for fetching environment variable-based
+                                 configuration values.
+            :param file_secret_settings: Callable source for fetching configuration values
+                                         from secret files.
+            :return: A tuple of callable sources representing the customized sequence of
+                     settings to be used.
+            """
+            return init_settings, env_settings, env_secrets_settings
+
+
+def env_secrets_settings(_settings: BaseSettings) -> dict[str, Any]:
+    """
+    Processes the given BaseSettings object to extract environment-specific
+    secret settings and returns them as a dictionary.
+
+    This function uses a YAML-safe loader to transform configuration
+    parameters managed by the config_manager into a dictionary of secrets,
+    specifically designed for applications with environment-specific settings.
+
+    :param _settings: An instance of BaseSettings that provides application
+        configuration settings.
+    :type _settings: BaseSettings
+    :return: A dictionary containing the parsed environment-specific
+        secret settings.
+    :rtype: dict[str, Any]
+    """
+    return yaml.safe_load(str(config_manager.parameters))
+
+
+# Initialize and validate configuration
+config_manager = ConfigManager(VALIDATION_RULES)
+config_manager.validate_configuration()
+
+# Check for any unset settings
+settings_not_set = config_manager.errors
+settings = Settings()