pyegeria 5.4.0.1__py3-none-any.whl → 5.4.0.3__py3-none-any.whl

pyegeria/load_config.py

@@ -0,0 +1,217 @@
+
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+This module manages configuration information for pyegeria and pyegeria clients.
+
+The load_app_config() function loads configuration information:
+1) Default configuration variables are specified in the Dict structure below.
+2) We construct a path to an external configuration JSON file from the Environment Variables
+    - PYEGERIA_ROOT_PATH
+    - PYEGERIA_CONFIG_FILE
+3) If a valid configuration file is found, the configuration will be loaded on top of the default configuration.
+4) We then update the in-memory configuration from Environment Variables, if set.
+
+The result is that Environment Variable values take priority over configuration file values which override the defaults.
+
+The get_app_config() function is used by other modules to get configuration information from the configuration structure
+and makes it available as a dict.
+
+"""
+import inspect
+import os
+import json
+from loguru import logger
+from pyegeria._exceptions_new import PyegeriaInvalidParameterException
+
+
+# from dotenv import load_dotenv # pip install python-dotenv if you use .env files
+
+# --- Configuration Loading Logic ---
+
+# Private variable to hold the loaded configuration
+_app_config = None
+
+def load_app_config():
+    """
+    Loads application configuration from files and environment variables.
+    This function should ideally be called only once at application startup.
+    """
+    global _app_config # Declare intent to modify the global _app_config
+
+    if _app_config is not None:
+        # Configuration already loaded, return existing instance
+        return _app_config
+
+
+    # Define default configuration values
+    config = {
+        "Environment": {
+                "Console Width": 200,
+                "Dr. Egeria Inbox": "md-processing/dr-egeria-inbox",
+                "Dr. Egeria Outbox": "md-processing/dr-egeria-outbox",
+                "Egeria Engine Host URL": "",
+                "Egeria Engine Host": "qs-engine-host",
+                "Egeria Glossary Path": "glossary",
+                "Egeria Integration Daemon URL": "https://localhost:9443",
+                "Egeria Integration Daemon": "qs-integration-daemon",
+                "Egeria Jupyter": True,
+                "Egeria Kafka Endpoint": "localhost:9192",
+                "Egeria Mermaid Folder": "mermaid_graphs",
+                "Egeria Metadata Store": "qs-metadata-store",
+                "Egeria Platform URL": "https://localhost:9443",
+                "Egeria View Server URL": "https://localhost:9443",
+                "Egeria View Server": "qs-view-server",
+                "Pyegeria Root": "/Users/dwolfson/localGit/egeria-v5-3/egeria-python",
+        },
+
+        "Debug": {
+                "debug_mode": False,
+                "enable_logger_catch": False,
+                "timeout_seconds": 30,
+        },
+        "feature_x_enabled": False,
+        "Logging": {
+                "console_filter_levels": [
+                        "ERROR"
+                ],
+                "console_logging_enabled": [
+                        "_client_new",
+                        "_exceptions_new",
+                        "collections_manager_omvs"
+                        "tests",
+                ],
+                "console_logging_level": "INFO",
+                "enable_logging": False,
+                "file_logging_level": "INFO",
+                "log_directory": "logs",
+                "logging_console_format":
+                    " <cyan>{name}</cyan>:<cyan>{line}</cyan> - <level>{message}</level> -{extra}",
+                    " <green>{time:YYYY-MM-DD HH:mm:ss}</green> | <level>{level}</level> |"
+                "logging_file_format":
+                    " {time:YYYY-MM-DD HH:mm:ss} | {level} | {function}:{line} - {message }-{extra}"
+        },
+        "User Profile": {
+                "Egeria Home Collection": "MyHome",
+                "Egeria Home Glossary Name": "Egeria-Markdown",
+                "Egeria Local Qualifier": "PDR"
+        }
+}
+
+    root_path = os.getenv("PYEGERIA_ROOT_PATH", config["Environment"].get("Pyegeria Root",""))
+    config_file = os.getenv("PYEGERIA_CONFIG_FILE", "config.json")
+    config_file_path = os.path.join(root_path,config_file)
+    if os.path.exists(config_file_path):
+        try:
+            with open(config_file_path, 'r') as f:
+                file_config = json.load(f)
+                config.update(file_config) # Merge/override defaults
+                # logger.debug("Configuration file loaded from {}".format(config_file_path))
+        except json.JSONDecodeError:
+            print(f"Warning: Could not parse {config_file_path}. Using defaults/env vars.")
+        except Exception as e:
+            print(f"Warning: Error reading {config_file_path}: {e}. Using defaults/env vars.")
+    else:
+        logger.warning(f"Warning: Could not find {config_file_path}. Using defaults/env vars.")
+
+    debug = config["Debug"]
+    debug['debug_mode'] = os.getenv("PYEGERIA_DEBUG_MODE", debug.get("debug_mode", False))
+    debug["enable_logger_catch"] = os.getenv("PYEGERIA_ENABLE_LOGGER_CATCH", debug.get("enable_logger_catch", False))
+    debug["timeout_seconds"] = int(os.getenv("PYEGERIA_TIMEOUT_SECONDS", debug.get("timeout_seconds", 30)))
+
+    env = config["Environment"]
+    env["Console Width"] = int(os.getenv("PYEGERIA_CONSOLE_WIDTH", env.get("EGERIA_WIDTH", 200)))
+    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"))
+    env["Egeria Engine Host URL"] = os.getenv("EGERIA_ENGINE_HOST_URL",env.get("Egeria Engine Host URL", "https://localhost:9443"))
+
+    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"] = os.getenv("EGERIA_JUPYTER", env.get("Egeria Jupyter", True))
+    env["Egeria Kafka"] = os.getenv("EGERIA_KAFKA", env.get("Egeria Kafka", "https://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 Root"] = root_path
+
+    log = config["Logging"]
+    log["console_filter_levels"] = os.getenv("PYEGERIA_CONSOLE_FILTER_LEVELS",
+                                                log.get("console_filter_levels", ["ERROR"]))
+    log["console_logging_enabled"] = os.getenv("PYEGERIA_CONSOLE_LOGGING_ENABLED",
+                                                  log.get("console_logging_enabled", ["tests"]))
+    log["console_logging_level"] = os.getenv("PYEGERIA_CONSOLE_LOG_LVL", log.get("console_logging_level", None))
+    log["enable_logging"] = os.getenv("PYEGERIA_ENABLE_LOGGING", 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 = config["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"))
+    user["user_name"] = os.getenv("EGERIA_USER_NAME", "peterprofile")
+    user["user_pwd"] = os.getenv("EGERIA_USER_PASSWORD", "secret")
+
+    if not user.get("user_pwd"):
+        context: dict = {}
+        context['caller method'] = inspect.currentframe().f_back.f_code.co_name
+        additional_info: dict = {"reason": "Egeria user password is not found in the environment"}
+        raise PyegeriaInvalidParameterException(None, context, additional_info)
+
+
+
+
+    # Handle type conversion for env vars (they are always strings)
+    # if "TIMEOUT_SECONDS" in os.environ:
+    #     try:
+    #         config["timeout_seconds"] = int(os.getenv("TIMEOUT_SECONDS"))
+    #     except ValueError:
+    #         print("Warning: TIMEOUT_SECONDS environment variable is not an integer. Using default.")
+    #
+    # if "DEBUG_MODE" in os.environ:
+    #     # Convert string "True", "False", "1", "0" to boolean
+    #     debug_str = os.getenv("DEBUG_MODE").lower()
+    #     config["debug_mode"] = debug_str in ('True', '1', 't', 'y', 'yes', 'on')
+    #
+    # if "FEATURE_X_ENABLED" in os.environ:
+    #     feature_x_str = os.getenv("FEATURE_X_ENABLED").lower()
+    #     config["feature_x_enabled"] = feature_x_str in ('True', '1', 't', 'y', 'yes', 'on')
+
+    # 4. Handle sensitive API key (only from environment variable)
+    # config["api_key"] = os.getenv("MY_SERVICE_API_KEY")
+    # if config["api_key"] is None:
+    #     print("Error: MY_SERVICE_API_KEY environment variable is critical and not set.")
+    #     # In a production application, you might raise a critical exception here:
+    #     # raise ValueError("MY_SERVICE_API_KEY is not set!")
+
+    _app_config = config # Store the final loaded configuration
+    return _app_config
+
+def get_app_config():
+    """
+    Provides access to the loaded application configuration.
+    Ensures config is loaded if not already (useful for testing or simple scripts).
+    For structured apps, load_app_config() should be called explicitly once at startup.
+    """
+    if _app_config is None:
+        # If get_app_config is called before load_app_config, load it now.
+        # This can be convenient but explicit loading is generally better.
+        return load_app_config()
+    return _app_config
+
+# You can also define constants based on the config for common access,
+# but be aware these won't update if the config changes after initial load.
+# E.g., API_ENDPOINT = get_app_config().get("api_endpoint")

pyegeria/logging_configuration.py

@@ -0,0 +1,204 @@
+
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+This module configures logging using loguru. The pyegeria library modules do not configure
+loguru automatically so that the calling application has control over the logging. However, if the
+calling application doesn't have its own logging setup, it can use this module to configure loguru logging.
+
+If the application uses another logging library, such as the built-in python logging, it can
+do so by redirecting loguru output. Here is an example:
+
+    # application.py - App uses standard logging, redirects Loguru)
+
+    import logging
+    import logging.config
+    import sys # For sys.stderr
+    from loguru import logger # Import Loguru's logger
+    from my_library.my_module import MyLibraryClass, library_function
+
+    # --- Standard Logging Configuration (for the application) ---
+    # This is your application's primary logging setup.
+    LOGGING_CONFIG = {
+        "version": 1,
+        "disable_existing_loggers": False,
+        "formatters": {
+            "standard": {
+                "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+            }
+        },
+        "handlers": {
+            "console": {
+                "class": "logging.StreamHandler",
+                "level": "INFO",
+                "formatter": "standard",
+                "stream": "ext://sys.stdout"
+            },
+            "file": {
+                "class": "logging.handlers.RotatingFileHandler",
+                "level": "DEBUG",
+                "formatter": "standard",
+                "filename": "app_standard.log",
+                "maxBytes": 10485760,
+                "backupCount": 5
+            }
+        },
+        "loggers": {
+            # Root logger for the application
+            "": { # Empty string means the root logger
+                "handlers": ["console", "file"],
+                "level": "DEBUG", # Set the overall minimum level here
+                "propagate": False
+            }
+        }
+    }
+
+    try:
+        logging.config.dictConfig(LOGGING_CONFIG)
+        app_logger = logging.getLogger(__name__)
+        app_logger.info("Application standard logging configured successfully.")
+    except Exception as e:
+        print(f"Error configuring standard logging: {e}. Falling back to basicConfig.")
+        logging.basicConfig(level=logging.INFO)
+        app_logger = logging.getLogger(__name__)
+        app_logger.warning("Using basic logging due to configuration error.")
+
+    # --- Integrate Loguru with Standard Logging ---
+    # This is the key to "disabling" Loguru's separate output.
+
+    # 1. Remove Loguru's default handler (which outputs to stderr)
+    logger.remove(0)
+
+    # 2. Add a handler to Loguru that redirects messages to the standard logging module.
+    #    The level here determines what Loguru sends to standard logging.
+    logger.add(
+        logging.StreamHandler(sys.stderr), # You can use any standard logging handler here
+        level="DEBUG", # Loguru will send messages at this level or higher to standard logging
+        format="{message}" # Keep Loguru's format simple, let standard logging handle formatting
+    )
+
+    # Optional: If you want to completely suppress Loguru's output and rely solely on standard logging
+    # for your library's messages, you can set Loguru's level to a very high value:
+    # logger.level("CRITICAL") # This would make it only log critical errors
+    # Or, if you want to completely disable it (not recommended for general use):
+    # logger.disable("my_library") # This disables logging for the 'my_library' hierarchy
+
+    app_logger.info("Loguru integrated with standard logging.")
+
+    # --- Main Application Logic ---
+    if __name__ == "__main__":
+        app_logger.info("Application started.")
+
+        # Your library's logs will now go through the standard logging system
+        my_instance = MyLibraryClass("test_value")
+        processed = my_instance.process_data("hello world")
+        app_logger.info("Processed data: %s", processed)
+
+        library_function()
+
+        try:
+            my_instance.perform_risky_operation()
+        except Exception:
+            app_logger.error("Caught exception from risky operation in library.")
+
+        app_logger.info("Application finished.")
+
+To suppress logging, an application can do the following:
+    # application.py (Scenario C: App wants library to be silent)
+
+    from loguru import logger
+    from my_library.my_module import MyLibraryClass, library_function
+
+    # Remove Loguru's default handler
+    logger.remove(0)
+
+    # Completely disable logging for the 'my_library' hierarchy
+    logger.disable("my_library")
+
+    logger.info("Application started. Loguru for 'my_library' is disabled.")
+
+    my_instance = MyLibraryClass("test_value")
+    processed = my_instance.process_data("hello world") # These will not be logged by library
+    logger.info("Processed data: %s", processed) # This will be logged by app's logger
+
+    library_function() # This will not be logged by library
+
+    logger.info("Application finished.")
+
+"""
+
+# application.py (Scenario A: App uses Loguru)
+import os, sys
+from loguru import logger
+from pyegeria.load_config import get_app_config
+
+# Load configuration parameters
+app_settings = get_app_config()
+
+def console_log_filter(record):
+    return (record["module"] in app_settings["Logging"]["console_logging_enabled"]
+            and
+            record["level"].name in app_settings["Logging"]["console_filter_levels"]
+            )
+
+
+
+def config_logging():
+    """
+    Configures logging for the application using Loguru.
+
+    This function sets up logging functionalities for the application. It reads
+    the necessary logging configurations, ensures the desired log directory exists,
+    and defines logging handlers for both file-based and console-based logging.
+    Log messages can be retained with a rotation and compression policy for file logs.
+
+    Raises:
+        OSError: If the log directory cannot be created.
+
+    """
+
+
+    # Get the directory for log files from the environment variable
+    log_app_settings = app_settings["Logging"]
+    log_directory = log_app_settings.get("log_directory","/Users/dwolfson/localGit/egeria-v-3/egeria-python/logs")
+    console_logging_level = log_app_settings.get("console_logging_level","SUCCESS")
+    logging_console_format = log_app_settings.get("console_format","{time:YYYY-MM-DD HH:mm:ss} | {level} | {module}:{line}"
+                                                               " - {message} - {extra}")
+    file_logging_level = log_app_settings.get("file_logging_level", "INFO")
+    logging_file_format = log_app_settings.get("file_format", "{time:YYYY-MM-DD HH:mm:ss} | {level} | {module}:{line}"
+                                                          " - {message} - {extra}")
+    console_logging_enabled = log_app_settings.get("console_logging_enabled", "tests")
+    enable_logging = log_app_settings.get("enable_logging", True)
+
+    # Ensure the directory exists
+    os.makedirs(log_directory, exist_ok=True)
+
+    # Define the log file path
+    log_file_path = os.path.join(log_directory, "pyegeria.log")
+    # Remove Loguru's default stderr handler (id=0) if you want full control
+    logger.remove()
+
+    # Add your desired handlers for the application (and thus the library)
+    logger.add(log_file_path,
+               level=file_logging_level,
+               format=logging_file_format,
+               filter = "",
+               retention="7 days",  # Keep logs for 7 days
+               rotation="10 MB", # rotate logs once they are 10mb
+               compression="zip")
+    logger.add(
+        sys.stderr,
+        level=console_logging_level,
+        format=logging_console_format,
+        filter=console_log_filter,
+        colorize=True
+    )
+
+    if enable_logging:
+        logger.enable("")
+    logger.info("Application started with Loguru configured.")
+
+
+
+