pyegeria 5.4.2.3__py3-none-any.whl → 5.4.3.1__py3-none-any.whl

pyegeria/config.py

@@ -27,7 +27,7 @@ import json
 from typing import List, Optional, Union, Dict, Any
 
 from loguru import logger
-from pydantic import BaseModel, Field, validator
+from pydantic import BaseModel, Field, validator, ConfigDict
 from pydantic_settings import BaseSettings, SettingsConfigDict
 
 from pyegeria._exceptions_new import PyegeriaInvalidParameterException, PyegeriaException
@@ -105,15 +105,13 @@ class EnvironmentConfig(BaseModel):
     egeria_platform_url: str = Field(default="https://localhost:9443", alias="Egeria Platform URL")
     egeria_view_server_url: str = Field(default="https://localhost:9443", alias="Egeria View Server URL")
     egeria_view_server: str = Field(default="qs-view-server", alias="Egeria View Server")
-    pyegeria_root: str = Field(default="/Users/dwolfson/localGit/egeria-v5-3/egeria-python", alias="Pyegeria Root")
+    pyegeria_root: str = Field(default="", alias="Pyegeria Root")
     pyegeria_config_directory: str = Field(default="", alias="Pyegeria Config Directory")
     pyegeria_config_file: str = Field(default="config.json", alias="Egeria Config File")
     pyegeria_publishing_root: str = Field(default="/dr-egeria-outbox", alias="Pyegeria Publishing Root")
     pyegeria_user_format_sets_dir: str = Field(default="~/.pyegeria/format_sets", alias="Pyegeria User Format Sets Dir")
     
-    class Config:
-        populate_by_name = True
-        extra = "allow"
+    model_config = ConfigDict(populate_by_name=True, extra='allow')
 
 
 class DebugConfig(BaseModel):
@@ -122,9 +120,7 @@ class DebugConfig(BaseModel):
     enable_logger_catch: bool = False
     timeout_seconds: int = 30
     
-    class Config:
-        populate_by_name = True
-        extra = "allow"
+    model_config = ConfigDict(populate_by_name=True, extra='allow')
 
 
 class LoggingConfig(BaseModel):
@@ -138,9 +134,7 @@ class LoggingConfig(BaseModel):
     logging_console_format: str = " <green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level}</level> | <cyan>{name}</cyan>:<cyan>{line}</cyan> - <level>{message}</level> -{extra}"
     logging_file_format: str = " {time:YYYY-MM-DD HH:mm:ss} | {level} | {function}:{line} - {message }-{extra}"
     
-    class Config:
-        populate_by_name = True
-        extra = "allow"
+    model_config = ConfigDict(populate_by_name=True, extra='allow')
 
 
 class UserProfileConfig(BaseModel):
@@ -151,21 +145,7 @@ class UserProfileConfig(BaseModel):
     user_name: Optional[str] = "erinoverview"
     user_pwd: Optional[str] = "secret"
     
-    @validator('user_name')
-    # def validate_user_name(cls, v):
-    #     if not v:
-    #         raise ValueError("Egeria user name is not found in the configuration")
-    #     return v
-    #
-    # @validator('user_pwd')
-    # def validate_user_pwd(cls, v):
-    #     if not v:
-    #         raise ValueError("Egeria user password is not found in the configuration")
-    #     return v
-    
-    class Config:
-        populate_by_name = True
-        extra = "allow"
+    model_config = ConfigDict(populate_by_name=True, extra='allow')
 
 
 class AppConfig(BaseModel):
@@ -210,9 +190,7 @@ class AppConfig(BaseModel):
         # If not found, return the default
         return default
     
-    class Config:
-        populate_by_name = True
-        extra = "allow"
+    model_config = ConfigDict(populate_by_name=True, extra='allow')
 
 
 # --- Configuration Loading Logic ---
@@ -220,7 +198,31 @@ class AppConfig(BaseModel):
 # Private variable to hold the loaded configuration
 _app_config = None
 
-def load_app_config(env_file: str = None):
+def _resolve_env_settings(env_file: str | None) -> PyegeriaSettings:
+    if env_file:
+        return PyegeriaSettings.with_env_file(env_file)
+    return PyegeriaSettings()
+
+
+def _find_config_file_path(settings: PyegeriaSettings) -> str | None:
+    config_dir = (settings.pyegeria_config_directory or "").strip()
+    root_path = (settings.pyegeria_root_path or "").strip()
+    config_file = (settings.pyegeria_config_file or "config.json").strip()
+
+    candidates = []
+    if config_dir:
+        candidates.append(os.path.join(config_dir, config_file))
+    if root_path:
+        candidates.append(os.path.join(root_path, config_file))
+    candidates.append(os.path.abspath(os.path.join(os.getcwd(), "config.json")))
+
+    for path in candidates:
+        if path and os.path.exists(path):
+            return path
+    return None
+
+
+def load_app_config(env_file: str | None = None):
     """
     Loads application configuration from files and environment variables.
     This function should ideally be called only once at application startup.
@@ -246,118 +248,57 @@ def load_app_config(env_file: str = None):
         # Configuration already loaded, return existing instance
         return _app_config
 
-    # Start with default configuration from Pydantic models
-    config_dict = {
+    # 1) Defaults from models
+    config_dict: dict[str, Any] = {
         "Environment": {},
         "Debug": {},
         "Logging": {},
         "User Profile": {},
-        "feature_x_enabled": False
+        "feature_x_enabled": False,
     }
-    
-    # Initialize env_settings with default values
-    env_settings = PyegeriaSettings()
-    
-    # First check if OS environment variables are set for PYEGERIA_CONFIG_DIRECTORY, PYEGERIA_ROOT_PATH and PYEGERIA_CONFIG_FILE
-    config_directory = os.getenv("PYEGERIA_CONFIG_DIRECTORY")
-    root_path = os.getenv("PYEGERIA_ROOT_PATH")
-    config_file = os.getenv("PYEGERIA_CONFIG_FILE")
-    
-    logger.info(f"DEBUG: Initial config_directory from OS env: {config_directory}")
-    logger.info(f"DEBUG: Initial root_path from OS env: {root_path}")
-    logger.info(f"DEBUG: Initial config_file from OS env: {config_file}")
-    logger.info(f"DEBUG: env_file parameter: {env_file}")
-    
-    # If env_file is specified, use it to load environment variables
-    if env_file is not None:
-        logger.trace(f"DEBUG: Loading environment variables from {env_file}")
-        env_settings = PyegeriaSettings.with_env_file(env_file)
-
-        # If env_file is specified, always use its values, regardless of OS environment variables
-        config_directory = env_settings.pyegeria_config_directory
-        root_path = env_settings.pyegeria_root_path
-        config_file = env_settings.pyegeria_config_file
-    # If config_file is set but config_directory and root_path are not, we'll try to load the config file first
-    # and only check the .env file if we still don't have a config_directory or root_path after loading the config file
-    elif config_file is not None and config_directory is None and root_path is None:
-        # We'll check for a .env file later if needed
-        pass
-    # If any of config_directory, root_path, or config_file is not set, check for a .env file in the current directory
-    elif (config_directory is None or root_path is None or config_file is None):
-        if os.path.exists(".env"):
-            logger.info("Found .env file")
-            logger.debug(f"DEBUG: Loading environment variables from .env in current directory")
-            env_settings = PyegeriaSettings()
-            logger.debug(f"DEBUG: env_settings.pyegeria_config_directory: {env_settings.pyegeria_config_directory}")
-            logger.debug(f"DEBUG: env_settings.pyegeria_root_path: {env_settings.pyegeria_root_path}")
-            logger.debug(f"DEBUG: env_settings.pyegeria_config_file: {env_settings.pyegeria_config_file}")
-            if config_directory is None:
-                config_directory = env_settings.pyegeria_config_directory
-            if root_path is None:
-                root_path = env_settings.pyegeria_root_path
-            if config_file is None:
-                config_file = env_settings.pyegeria_config_file
-        else:
-            logger.error(f"The .env file at {env_file} wasn't found")
-    else:
-        logger.error(f"The .env file at {env_file} wasn't found-outer")
-    # Use default values if still not set
-    if config_directory is None:
-        config_directory = ""
-    if root_path is None:
-        root_path = ""
-    if config_file is None:
-        config_file = "config.json"
-    
-    # Construct the config file path - prefer config_directory over root_path
-    if config_directory:
-        config_file_path = os.path.join(config_directory, config_file)
-    else:
-        config_file_path = os.path.join(root_path, config_file)
-    
-    if os.path.exists(config_file_path):
-        logger.info("Found config file at {}".format(config_file_path))
+
+    # 2) Load env settings from OS/.env according to env_file
+    env_settings = _resolve_env_settings(env_file)
+
+    # 3) Load config file if found
+    file_path = _find_config_file_path(env_settings)
+    if file_path:
+        logger.info(f"Using config file: {file_path}")
         try:
-            with open(config_file_path, 'r') as f:
-                file_config = json.load(f)
-                config_dict.update(file_config)  # Merge/override defaults
-                
-                # If config_directory is not set from environment variables or .env file,
-                # set it from the config file if available
-                if not config_directory and "Environment" in file_config and "Pyegeria Config Directory" in file_config["Environment"]:
-                    config_directory = file_config["Environment"]["Pyegeria Config Directory"]
-                    logger.debug(f"DEBUG: Setting config_directory from config file: {config_directory}")
-                # If config_directory is still not set and root_path is not set from environment variables or .env file,
-                # set root_path from the config file if available
-                if not config_directory and not root_path and "Environment" in file_config and "Pyegeria Root" in file_config["Environment"]:
-                    root_path = file_config["Environment"]["Pyegeria Root"]
-                    logger.debug(f"DEBUG: Setting root_path from config file: {root_path}")
-        except json.JSONDecodeError:
-            logger.warning(f"Warning: Could not parse {config_file_path}. Using defaults/env vars.")
+            with open(file_path, "r") as f:
+                file_cfg = json.load(f)
+                if isinstance(file_cfg, dict):
+                    config_dict.update(file_cfg)
+                else:
+                    logger.warning("Config file root is not an object; ignoring.")
         except Exception as e:
-            logger.warning(f"Warning: Error reading {config_file_path}: {e}. Using defaults/env vars.")
+            logger.warning(f"Could not read/parse config file '{file_path}': {e}. Continuing with defaults+env.")
     else:
-        logger.warning(f"Warning: Could not find {config_file_path}. Using defaults/env vars.")
-
-    # The root_path has already been set with the correct precedence order:
-    # 1. If env_file is passed in, use that file to load environment variables
-    # 2. Otherwise, first check OS environment variables
-    # 3. If not set, check for a .env file in the current directory
-    # 4. If still not set, use the default value
-    # We don't need to set it again here, as that would override the precedence order
-    env = config_dict.get("Environment", {})
-
-    # Update configuration from environment variables
-    # Debug section
-    debug = config_dict["Debug"]
-    debug['debug_mode'] = _parse_bool_env("PYEGERIA_DEBUG_MODE", debug.get("debug_mode", False))
-    debug["enable_logger_catch"] = _parse_bool_env("PYEGERIA_ENABLE_LOGGER_CATCH", debug.get("enable_logger_catch", False))
-    debug["timeout_seconds"] = int(os.getenv("PYEGERIA_TIMEOUT_SECONDS", debug.get("timeout_seconds", 30)))
-
-    # Environment section
-    env = config_dict["Environment"]
-    # Use the settings from .env file, but allow OS environment variables to override them
+        logger.debug("No config.json found; continuing with defaults + env.")
+
+    # 4) Overlay environment variables
+    # Debug
+    dbg = config_dict.setdefault("Debug", {})
+    dbg["debug_mode"] = _parse_bool_env("PYEGERIA_DEBUG_MODE", bool(dbg.get("debug_mode", False)))
+    dbg["enable_logger_catch"] = _parse_bool_env("PYEGERIA_ENABLE_LOGGER_CATCH", bool(dbg.get("enable_logger_catch", False)))
+    dbg["timeout_seconds"] = int(os.getenv("PYEGERIA_TIMEOUT_SECONDS", dbg.get("timeout_seconds", 30)))
+
+    # Environment
+    env = config_dict.setdefault("Environment", {})
+    default_root = env.get("Pyegeria Root") or os.getcwd()
+    env_config_dir = os.getenv("PYEGERIA_CONFIG_DIRECTORY", env_settings.pyegeria_config_directory or "")
+    env_root = os.getenv("PYEGERIA_ROOT_PATH", env_settings.pyegeria_root_path or default_root)
+    env_config_file = os.getenv("PYEGERIA_CONFIG_FILE", env_settings.pyegeria_config_file or "config.json")
+
+    env["Pyegeria Config Directory"] = env_config_dir
+    env["pyegeria_config_directory"] = env_config_dir
+    env["Pyegeria Root"] = env_root
+    env["pyegeria_root"] = env_root
+    env["Egeria Config File"] = env_config_file
+    env["pyegeria_config_file"] = env_config_file
+
     env["Console Width"] = int(os.getenv("PYEGERIA_CONSOLE_WIDTH", env.get("Console Width", env_settings.pyegeria_console_width)))
+    env["console_width"] = env["Console Width"]
     env["Dr.Egeria Inbox"] = os.getenv("DR_EGERIA_INBOX_PATH", env.get("Dr.Egeria Inbox", "md_processing/dr-egeria-inbox"))
     env["Dr.Egeria Outbox"] = os.getenv("DR_EGERIA_OUTBOX_PATH", env.get("Dr.Egeria Outbox", "md_processing/dr-egeria-outbox"))
     env["Egeria Engine Host"] = os.getenv("EGERIA_ENGINE_HOST", env.get("Egeria Engine Host", "qs-engine-host"))
@@ -365,79 +306,56 @@ def load_app_config(env_file: str = None):
     env["Egeria Glossary Path"] = os.getenv("EGERIA_GLOSSARY_PATH", env.get("Egeria Glossary Path", "glossary"))
     env["Egeria Integration Daemon"] = os.getenv("EGERIA_INTEGRATION_DAEMON", env.get("Egeria Integration Daemon", "qs-integration-daemon"))
     env["Egeria Integration Daemon URL"] = os.getenv("EGERIA_INTEGRATION_DAEMON_URL", env.get("Egeria Integration Daemon URL", "https://localhost:9443"))
-    env["Egeria Jupyter"] = _parse_bool_env("EGERIA_JUPYTER", env.get("Egeria Jupyter", True))
+    env["Egeria Jupyter"] = _parse_bool_env("EGERIA_JUPYTER", bool(env.get("Egeria Jupyter", True)))
     env["Egeria Kafka Endpoint"] = os.getenv("EGERIA_KAFKA", env.get("Egeria Kafka Endpoint", "localhost:9192"))
     env["Egeria Mermaid Folder"] = os.getenv("EGERIA_MERMAID_FOLDER", env.get("Egeria Mermaid Folder", "mermaid_graphs"))
     env["Egeria Metadata Store"] = os.getenv("EGERIA_METADATA_STORE", env.get("Egeria Metadata Store", "qs-metadata-store"))
     env["Egeria Platform URL"] = os.getenv("EGERIA_PLATFORM_URL", env.get("Egeria Platform URL", "https://localhost:9443"))
     env["Egeria View Server"] = os.getenv("EGERIA_VIEW_SERVER", env.get("Egeria View Server", "qs-view-server"))
     env["Egeria View Server URL"] = os.getenv("EGERIA_VIEW_SERVER_URL", env.get("Egeria View Server URL", "https://localhost:9443"))
-    env['Pyegeria Publishing Root'] = os.getenv("PYEGERIA_PUBLISHING_ROOT", env.get("Pyegeria Publishing Root", "/dr-egeria-outbox"))
-    env['Pyegeria User Format Sets Dir'] = os.getenv("PYEGERIA_USER_FORMAT_SETS_DIR", env.get("Pyegeria User Format Sets Dir", "~/.pyegeria/format_sets"))
-    # Set Pyegeria Config Directory to the config_directory value we've already determined with the correct precedence order
-    env["Pyegeria Config Directory"] = config_directory
-    # Set Pyegeria Root to the root_path value we've already determined with the correct precedence order
-    env["Pyegeria Root"] = root_path
-
-    # Logging section
-    log = config_dict["Logging"]
-    log["console_filter_levels"] = _parse_list_env("PYEGERIA_CONSOLE_FILTER_LEVELS", log.get("console_filter_levels", ["ERROR","WARNING","INFO","SUCCESS"]))
+    env["Pyegeria Publishing Root"] = os.getenv("PYEGERIA_PUBLISHING_ROOT", env.get("Pyegeria Publishing Root", "/dr-egeria-outbox"))
+    env["Pyegeria User Format Sets Dir"] = os.getenv("PYEGERIA_USER_FORMAT_SETS_DIR", env.get("Pyegeria User Format Sets Dir", "~/.pyegeria/format_sets"))
+
+    # Logging
+    log = config_dict.setdefault("Logging", {})
+    log["console_filter_levels"] = _parse_list_env("PYEGERIA_CONSOLE_FILTER_LEVELS", log.get("console_filter_levels", ["ERROR", "WARNING", "INFO", "SUCCESS"]))
     log["console_logging_enabled"] = _parse_list_env("PYEGERIA_CONSOLE_LOGGING_ENABLED", log.get("console_logging_enabled", ["pyegeria"]))
     log["console_logging_level"] = os.getenv("PYEGERIA_CONSOLE_LOG_LVL", log.get("console_logging_level", "INFO"))
-    log["enable_logging"] = _parse_bool_env("PYEGERIA_ENABLE_LOGGING", log.get("enable_logging", False))
+    log["enable_logging"] = _parse_bool_env("PYEGERIA_ENABLE_LOGGING", bool(log.get("enable_logging", False)))
     log["file_logging_level"] = os.getenv("PYEGERIA_FILE_LOG_LVL", log.get("file_logging_level", "INFO"))
-    log["log_directory"] = os.getenv("PYEGERIA_LOG_DIRECTORY", log.get("log_directory", 'logs'))
-    log["logging_console_format"] = os.getenv("PYEGERIA_LOGGING_CONSOLE_FORMAT", log.get("logging_console_format",
-                                             "<green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level}</level> | "
-                                             "<cyan>{name}</cyan>:<cyan>{line}</cyan> - "
-                                             "<level>{message}</level> -{extra}"))
-    log["logging_file_format"] = os.getenv("PYEGERIA_LOGGING_FILE_FORMAT", log.get("logging_file_format",
-                                           "{time:YYYY-MM-DD HH:mm:ss} | {level} | {function}:{line} "
-                                           "- {message}-{extra}"))
-
-    # User Profile section
-    user = config_dict["User Profile"]
-    user["Egeria Home Collection"] = os.getenv("EGERIA_HOME_COLLECTION", user.get("Egeria Home Collection", "myHome"))
+    log["log_directory"] = os.getenv("PYEGERIA_LOG_DIRECTORY", log.get("log_directory", "logs"))
+    log["logging_console_format"] = os.getenv(
+        "PYEGERIA_LOGGING_CONSOLE_FORMAT",
+        log.get(
+            "logging_console_format",
+            " <green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level}</level> | <cyan>{name}</cyan>:<cyan>{line}</cyan> - <level>{message}</level> -{extra}",
+        ),
+    )
+    log["logging_file_format"] = os.getenv(
+        "PYEGERIA_LOGGING_FILE_FORMAT",
+        log.get("logging_file_format", " {time:YYYY-MM-DD HH:mm:ss} | {level} | {function}:{line} - {message }-{extra}"),
+    )
+
+    # User Profile
+    user = config_dict.setdefault("User Profile", {})
+    user["Egeria Home Collection"] = os.getenv("EGERIA_HOME_COLLECTION", user.get("Egeria Home Collection", "MyHome"))
     user["Egeria Home Glossary Name"] = os.getenv("EGERIA_HOME_GLOSSARY_NAME", user.get("Egeria Home Glossary Name", "Egeria-Markdown"))
-    user["Egeria Local Qualifier"] = os.getenv("EGERIA_LOCAL_QUALIFIER", user.get("Egeria Local Qualifier", "myLocal"))
-    
-    # Load user credentials with proper precedence
-    # 1. Check OS environment variables
-    user_name = os.getenv("EGERIA_USER")
-    user_pwd = os.getenv("EGERIA_USER_PASSWORD")
-    
-    # 2. If not set, check config file
-    if user_name is None:
-        user_name = user.get("user_name")
-    if user_pwd is None:
-        user_pwd = user.get("user_pwd")
-    
-    # 3. If still not set and we have env_settings, check .env file
-    if (user_name is None or user_pwd is None) and 'env_settings' in locals():
-        if user_name is None:
-            user_name = env_settings.egeria_user_name
-        if user_pwd is None:
-            user_pwd = env_settings.egeria_user_password
-    
-    # Set the values in the config dictionary
+    user["Egeria Local Qualifier"] = os.getenv("EGERIA_LOCAL_QUALIFIER", user.get("Egeria Local Qualifier", "PDR"))
+
+    user_name = os.getenv("EGERIA_USER", user.get("user_name") or env_settings.egeria_user_name or None)
+    user_pwd = os.getenv("EGERIA_USER_PASSWORD", user.get("user_pwd") or env_settings.egeria_user_password or None)
     user["user_name"] = user_name
     user["user_pwd"] = user_pwd
 
     # Feature flags
-    # Ensure feature_x_enabled is a boolean, regardless of what's in the config file
-    feature_x = config_dict.get("feature_x_enabled", False)
-    feature_x = _parse_bool_value(feature_x)
-    # Check if the environment variable is set, which would override the config value
-    if "FEATURE_X_ENABLED" in os.environ:
-        feature_x = _parse_bool_value(os.getenv("FEATURE_X_ENABLED"))
+    feature_x = _parse_bool_value(os.getenv("FEATURE_X_ENABLED", config_dict.get("feature_x_enabled", False)))
     config_dict["feature_x_enabled"] = feature_x
 
+    # Debug print of env before model creation
     try:
-        # Create Pydantic model from the configuration dictionary
-        # _app_config = AppConfig(**config_dict) <-- why? todo
-        _app_config = AppConfig()
-    except ValueError as e:
-        # Handle validation errors from Pydantic
+        logger.info(f"DEBUG ENV SECTION: {config_dict.get('Environment')}")
+        _app_config = AppConfig(**config_dict)
+    except Exception as e:
         context = {"caller method": inspect.currentframe().f_back.f_code.co_name}
         additional_info = {"reason": str(e)}
         raise PyegeriaInvalidParameterException(None, context, additional_info)
@@ -521,4 +439,188 @@ def _parse_list_env(env_var: str, default: List[str]) -> List[str]:
     return default
 
 
-settings = get_app_config()
+# Export a lazily-evaluated settings accessor to avoid import-time side effects
+class _LazySettings:
+    def __getattr__(self, name):
+        cfg = get_app_config()
+        return getattr(cfg, name)
+
+settings = _LazySettings()
+
+
+def pretty_print_config(env_file: str | None = None, safe: bool = True, to_console: bool = True) -> Dict[str, Dict[str, Any]]:
+    """
+    Pretty print the current configuration and indicate the source of each value
+    (Environment, .env file, config file, or default). Uses Rich if available.
+
+    Args:
+        env_file: Optional .env path to force loading before printing (if config not yet loaded).
+        safe: Mask sensitive values such as passwords/tokens.
+        to_console: If True, prints to console; function always returns a structured dict.
+
+    Returns:
+        dict mapping section -> { key -> {"value": ..., "source": ...} }
+    """
+    # Ensure config is loaded
+    cfg = get_app_config(env_file)
+
+    # Try import rich lazily
+    try:
+        from rich.console import Console
+        from rich.table import Table
+        from rich import box
+        console = Console(width=getattr(cfg.Environment, 'console_width', 200))
+        use_rich = True
+    except Exception:
+        console = None
+        use_rich = False
+
+    # Helper to mask sensitive keys
+    def _mask(key: str, val: Any) -> Any:
+        if not safe:
+            return val
+        key_l = (key or "").lower()
+        if any(s in key_l for s in ["password", "pwd", "secret", "token", "apikey", "api_key"]):
+            if val is None:
+                return None
+            s = str(val)
+            if len(s) <= 4:
+                return "****"
+            return s[:2] + "****" + s[-2:]
+        return val
+
+    # Determine sources. Because we merge defaults, config.json, and env, we infer source:
+    # - If an OS env var exists for a specific setting name we used, it's "env".
+    # - Else if a config file was found (by our path resolver) and provided an override, mark "config".
+    # - Else if value equals model default and neither env nor config provided, "default".
+
+    # We need to reconstruct which keys are influenced by ENV VAR names.
+    env_var_map = {
+        # Debug
+        ("Debug", "debug_mode"): "PYEGERIA_DEBUG_MODE",
+        ("Debug", "enable_logger_catch"): "PYEGERIA_ENABLE_LOGGER_CATCH",
+        ("Debug", "timeout_seconds"): "PYEGERIA_TIMEOUT_SECONDS",
+        # Environment
+        ("Environment", "Console Width"): "PYEGERIA_CONSOLE_WIDTH",
+        ("Environment", "Dr.Egeria Inbox"): "DR_EGERIA_INBOX_PATH",
+        ("Environment", "Dr.Egeria Outbox"): "DR_EGERIA_OUTBOX_PATH",
+        ("Environment", "Egeria Engine Host"): "EGERIA_ENGINE_HOST",
+        ("Environment", "Egeria Engine Host URL"): "EGERIA_ENGINE_HOST_URL",
+        ("Environment", "Egeria Glossary Path"): "EGERIA_GLOSSARY_PATH",
+        ("Environment", "Egeria Integration Daemon"): "EGERIA_INTEGRATION_DAEMON",
+        ("Environment", "Egeria Integration Daemon URL"): "EGERIA_INTEGRATION_DAEMON_URL",
+        ("Environment", "Egeria Jupyter"): "EGERIA_JUPYTER",
+        ("Environment", "Egeria Kafka Endpoint"): "EGERIA_KAFKA",
+        ("Environment", "Egeria Mermaid Folder"): "EGERIA_MERMAID_FOLDER",
+        ("Environment", "Egeria Metadata Store"): "EGERIA_METADATA_STORE",
+        ("Environment", "Egeria Platform URL"): "EGERIA_PLATFORM_URL",
+        ("Environment", "Egeria View Server"): "EGERIA_VIEW_SERVER",
+        ("Environment", "Egeria View Server URL"): "EGERIA_VIEW_SERVER_URL",
+        ("Environment", "Pyegeria Publishing Root"): "PYEGERIA_PUBLISHING_ROOT",
+        ("Environment", "Pyegeria User Format Sets Dir"): "PYEGERIA_USER_FORMAT_SETS_DIR",
+        ("Environment", "Pyegeria Root"): "PYEGERIA_ROOT_PATH",
+        ("Environment", "Pyegeria Config Directory"): "PYEGERIA_CONFIG_DIRECTORY",
+        ("Environment", "Egeria Config File"): "PYEGERIA_CONFIG_FILE",
+        # Logging
+        ("Logging", "console_filter_levels"): "PYEGERIA_CONSOLE_FILTER_LEVELS",
+        ("Logging", "console_logging_enabled"): "PYEGERIA_CONSOLE_LOGGING_ENABLED",
+        ("Logging", "console_logging_level"): "PYEGERIA_CONSOLE_LOG_LVL",
+        ("Logging", "enable_logging"): "PYEGERIA_ENABLE_LOGGING",
+        ("Logging", "file_logging_level"): "PYEGERIA_FILE_LOG_LVL",
+        ("Logging", "log_directory"): "PYEGERIA_LOG_DIRECTORY",
+        ("Logging", "logging_console_format"): "PYEGERIA_LOGGING_CONSOLE_FORMAT",
+        ("Logging", "logging_file_format"): "PYEGERIA_LOGGING_FILE_FORMAT",
+        # User profile
+        ("User Profile", "Egeria Home Collection"): "EGERIA_HOME_COLLECTION",
+        ("User Profile", "Egeria Home Glossary Name"): "EGERIA_HOME_GLOSSARY_NAME",
+        ("User Profile", "Egeria Local Qualifier"): "EGERIA_LOCAL_QUALIFIER",
+        ("User Profile", "user_name"): "EGERIA_USER",
+        ("User Profile", "user_pwd"): "EGERIA_USER_PASSWORD",
+        # Feature flag example
+        (None, "feature_x_enabled"): "FEATURE_X_ENABLED",
+    }
+
+    # Attempt to detect if a config.json was used
+    env_settings = _resolve_env_settings(env_file)
+    config_file_path = _find_config_file_path(env_settings)
+
+    # Build a snapshot of defaults by instantiating empty models
+    defaults = {
+        "Environment": EnvironmentConfig().model_dump(by_alias=True),
+        "Debug": DebugConfig().model_dump(by_alias=True),
+        "Logging": LoggingConfig().model_dump(by_alias=False),
+        "User Profile": UserProfileConfig().model_dump(by_alias=True),
+        "feature_x_enabled": False,
+    }
+
+    # Current values from cfg
+    sections = [
+        ("Environment", cfg.Environment.model_dump(by_alias=True)),
+        ("Debug", cfg.Debug.model_dump(by_alias=False)),
+        ("Logging", cfg.Logging.model_dump(by_alias=False)),
+        ("User Profile", cfg.User_Profile.model_dump(by_alias=True)),
+    ]
+
+    result: Dict[str, Dict[str, Any]] = {}
+
+    for section_name, values in sections:
+        section_out: Dict[str, Any] = {}
+        for key, val in values.items():
+            # Prefer alias keys in display; ensure key exists in defaults appropriately
+            default_section = defaults.get(section_name, {})
+            default_val = default_section.get(key, None)
+
+            # Identify env var used for this key if any
+            env_var = env_var_map.get((section_name, key))
+            source = "default"
+            if env_var and env_var in os.environ:
+                source = "env"
+            elif config_file_path and (key in (defaults.get(section_name, {}) or {}) or True):
+                # If a config file exists and value differs from default and no env var set
+                if val != default_val:
+                    source = "config"
+                else:
+                    source = "default"
+            else:
+                source = "default"
+
+            section_out[key] = {
+                "value": _mask(key, val),
+                "source": source,
+            }
+        result[section_name] = section_out
+
+    # Add top-level feature flags
+    feat_val = getattr(cfg, "feature_x_enabled", False)
+    source = "env" if ("FEATURE_X_ENABLED" in os.environ) else ("config" if config_file_path and feat_val != defaults["feature_x_enabled"] else "default")
+    result["feature_x_enabled"] = {"value": _mask("feature_x_enabled", feat_val), "source": source}
+
+    if to_console:
+        if use_rich and console:
+            for section_name in ["Environment", "Debug", "Logging", "User Profile"]:
+                table = Table(title=f"{section_name} Settings", box=box.SIMPLE_HEAVY)
+                table.add_column("Key")
+                table.add_column("Value")
+                table.add_column("Source")
+                for k, info in result[section_name].items():
+                    table.add_row(str(k), str(info["value"]), info["source"])
+                console.print(table)
+            # Feature flags
+            table = Table(title="Feature Flags", box=box.SIMPLE_HEAVY)
+            table.add_column("Key")
+            table.add_column("Value")
+            table.add_column("Source")
+            ff = result["feature_x_enabled"]
+            table.add_row("feature_x_enabled", str(ff["value"]), ff["source"])
+            console.print(table)
+        else:
+            # Plain text fallback
+            print("Configuration:")
+            for section_name in ["Environment", "Debug", "Logging", "User Profile"]:
+                print(f"[{section_name}]")
+                for k, info in result[section_name].items():
+                    print(f"- {k}: {info['value']} (source: {info['source']})")
+            ff = result["feature_x_enabled"]
+            print(f"feature_x_enabled: {ff['value']} (source: {ff['source']})")
+
+    return result

pyegeria/glossary_manager.py

@@ -2245,9 +2245,9 @@ class GlossaryManager(CollectionManager):
 
         if body is None:
             body = {
-                "class": "RelationshipRequestBody",
+                "class": "NewRelationshipRequestBody",
                 "properties":
-                    {"class": "GlossaryTermRelationship", }
+                    {"class": "GlossaryTermRelationship" }
                 }
 
 

pyegeria/load_config.py

@@ -0,0 +1,36 @@
+"""
+Compatibility shim for legacy imports.
+Re-exports configuration loading utilities from pyegeria.config.
+"""
+# Import config lazily inside functions to avoid import-time side effects in tests
+from importlib import import_module
+
+def load_app_config(env_file: str | None = None):
+    return import_module('pyegeria.config').load_app_config(env_file)
+
+def get_app_config(env_file: str | None = None):
+    return import_module('pyegeria.config').get_app_config(env_file)
+
+class PyegeriaSettings:
+    def __new__(cls, *args, **kwargs):
+        # Construct a real settings instance from pyegeria.config
+        return import_module('pyegeria.config').PyegeriaSettings(*args, **kwargs)
+
+    @classmethod
+    def with_env_file(cls, env_file: str):
+        return import_module('pyegeria.config').PyegeriaSettings.with_env_file(env_file)
+
+# expose the cached instance for tests that reset it directly
+from . import config as _config
+
+def __getattr__(name):
+    if name == "_app_config":
+        return _config._app_config
+    raise AttributeError(name)
+
+
+def __setattr__(name, value):
+    if name == "_app_config":
+        _config._app_config = value
+    else:
+        globals()[name] = value