pyegeria 5.4.0.28__py3-none-any.whl → 5.5.3.3__py3-none-any.whl

commands/cat/{list_format_set.py → run_report_orig.py}

@@ -3,7 +3,7 @@
 SPDX-License-Identifier: Apache-2.0
 Copyright Contributors to the ODPi Egeria project.
 
-A command that takes an output format set name, looks up the format set using select_output_format_set,
+A command that takes an output format set name, looks up the format set using select_report_spec,
 and invokes the specified function with parameters filled from command line arguments.
 
 This command works with any format set defined in output_formatter.py that has an "action" property.
@@ -12,7 +12,7 @@ and prompts for any required parameters that aren't provided on the command line
 
 Features:
 - Works with any format set that has an "action" property
-- Dynamically adds command-line arguments based on the format set's user_params
+- Dynamically adds command-line arguments based on the format set's required/optional parameters
 - Prompts for required parameters if not provided
 - Supports multiple output formats (TABLE, DICT, FORM, REPORT, HTML, LIST)
 - Handles both instance methods and standalone functions
@@ -40,23 +40,23 @@ import os
 import time
 
 from loguru import logger
+from pydantic import ValidationError
 from rich import box
 from rich.console import Console
 from rich.markdown import Markdown
 from rich.prompt import Prompt
 from rich.table import Table
-from rich.text import Text
-import pydevd_pycharm
 
 from pyegeria import (
     EgeriaTech,
     CollectionManager,
-    NO_ELEMENTS_FOUND, GovernanceOfficer,
-    )
-from pyegeria.config import settings
-from pyegeria.logging_configuration import config_logging
-from pyegeria._output_formats import (select_output_format_set, get_output_format_set_heading, get_output_format_set_description)
-from pyegeria._exceptions_new import PyegeriaException, print_exception_response
+    NO_ELEMENTS_FOUND, GovernanceOfficer, GlossaryManager, print_validation_error,
+)
+from pyegeria.core.config import settings
+from pyegeria.omvs.external_links import ExternalReferences
+from pyegeria.core.logging_configuration import config_logging
+from pyegeria.view.base_report_formats import (select_report_format)
+from pyegeria.core._exceptions import PyegeriaException, print_exception_response
 
 # pydevd_pycharm.settrace('host.docker.internal',  # Use 'host.docker.internal' to connect to the host machine
 #                              port=5678,               # Port to communicate with PyCharm
@@ -117,7 +117,7 @@ def execute_format_set_action(
     # Get the output format set
     # logger.info(f"Entering execute_format_set_action, format set name: {format_set_name}, search_string: {kwargs.get('search_string',"meow")}")
     # logger.info(json.dumps(kwargs, indent=2))
-    format_set = select_output_format_set(format_set_name, output_format)
+    format_set = select_report_format(format_set_name, output_format)
     if not format_set:
         print(f"Error: Output format set '{format_set_name}' does not have a format compatible with output format '{output_format}'.")
         return
@@ -130,23 +130,102 @@ def execute_format_set_action(
     # Extract the function and parameters from the action property (now a dict)
     action = format_set["action"]
     func = action.get("function")
-    user_params = action.get("user_params", [])
+    required_params = action.get("required_params", action.get("user_params", []))
+    optional_params = action.get("optional_params", [])
     spec_params = action.get("spec_params", {})
     
-    # Create a params dictionary from user_params and spec_params
+    # Create a params dictionary from required/optional and spec_params
     params = {}
-    for param in user_params:
+    for param in required_params:
         if param in kwargs and kwargs[param]:
             params[param] = kwargs[param]
-            # print(f"Found value '{kwargs[param]}' for parameter '{param}'.")
         elif param not in kwargs and param not in spec_params:
             print(f"Warning: Required parameter '{param}' not provided for format set '{format_set_name}'.")
+    for param in optional_params:
+        if param in kwargs and kwargs[param]:
+            params[param] = kwargs[param]
     
     # Add spec_params to params
     params.update(spec_params)
 
-    params['output_format'] = output_format
-    params['output_format_set'] = format_set_name
+    # Delegate execution to exec_report_spec for canonical behavior
+    from pyegeria.view.format_set_executor import exec_report_spec
+    ofmt = (output_format or "TABLE").upper()
+    mapped = "DICT" if ofmt == "TABLE" else ofmt
+    res = exec_report_spec(
+        format_set_name,
+        output_format=mapped,
+        params=params,
+        view_server=view_server,
+        view_url=view_url,
+        user=user,
+        user_pass=user_pass,
+    )
+
+    # Handle TABLE rendering locally
+    if ofmt == "TABLE":
+        if res.get("kind") != "json":
+            print("No results or unexpected response:", res)
+            return
+        data = res.get("data")
+        # Render basic table
+        table = Table(
+            title=f"{format_set_name} @ {time.asctime()}",
+            style="bright_white on black",
+            header_style="bright_white on dark_blue",
+            title_style="bold white on black",
+            caption_style="white on black",
+            show_lines=True,
+            box=box.ROUNDED,
+            caption=f"View Server '{view_server}' @ Platform - {view_url}",
+            expand=True,
+        )
+        rows = data if isinstance(data, list) else [data]
+        if rows and isinstance(rows[0], dict):
+            cols = list(rows[0].keys())
+            for c in cols:
+                table.add_column(str(c), justify="left", style="cyan")
+            for r in rows:
+                table.add_row(*[str(r.get(c, "")) for c in cols])
+        else:
+            table.add_column("Value")
+            for r in rows:
+                table.add_row(str(r))
+        # Optional header
+        from pyegeria.view.base_report_formats import get_report_format_heading, get_report_format_description
+        heading = get_report_format_heading(format_set_name)
+        desc = get_report_format_description(format_set_name)
+        if heading and desc:
+            console.print(Markdown(f"# {heading}\n{desc}\n"))
+        console.print(table)
+        return
+
+    # For non-table formats, write to file based on MIME/kind
+    kind = res.get("kind")
+    mime = res.get("mime")
+    out_dir = os.path.join(app_config.pyegeria_root, app_config.dr_egeria_outbox)
+    ts = time.strftime('%Y-%m-%d-%H-%M-%S')
+    safe_name = "".join(c for c in format_set_name if c.isalnum() or c in ("-","_","+","."," ")).strip().replace(" ", "_")
+
+    if kind == "text":
+        content = res.get("content", "")
+        ext = ".html" if mime == "text/html" else ".md"
+    elif kind == "json":
+        content = json.dumps(res.get("data"), indent=2)
+        ext = ".json"
+    else:
+        content = json.dumps(res, indent=2, default=str)
+        ext = ".txt"
+
+    file_name = f"{safe_name}-{ts}{ext}"
+    full_file_path = os.path.join(out_dir, file_name)
+    os.makedirs(os.path.dirname(full_file_path), exist_ok=True)
+    with open(full_file_path, "w", encoding="utf-8") as f:
+        f.write(content)
+    print(f"\n==> Output written to {full_file_path}")
+    if ext == ".html":
+        print(f"\n==> Web link: [{file_name}]({app_config.pyegeria_publishing_root}/{file_name})")
+    return
 
     # Determine the appropriate client class based on the format set name or function
     client_class = None
@@ -159,6 +238,10 @@ def execute_format_set_action(
             client_class = CollectionManager
         elif class_name == "GovernanceOfficer":
             client_class = GovernanceOfficer
+        elif class_name == "GlossaryManager":
+            client_class = GlossaryManager
+        elif class_name == "ExternalReference":
+            client_class = ExternalReferences
         else:
             client_class = EgeriaTech
 
@@ -194,8 +277,8 @@ def execute_format_set_action(
     client.create_egeria_bearer_token()
 
     # Get heading and description information
-    heading = get_output_format_set_heading(format_set_name)
-    desc = get_output_format_set_description(format_set_name)
+    heading = get_report_format_heading(format_set_name)
+    desc = get_report_format_description(format_set_name)
     preamble = f"# {heading}\n{desc}\n\n" if heading and desc else ""
 
     try:
@@ -221,12 +304,16 @@ def execute_format_set_action(
             # Call the function with the parameters
             print(f"\n==> Calling function: {func} with parameters:{params}")
             try:
-                if isinstance(func, type(client.find_collections)):  # It's a method of the client
+                if callable(func):
                     # Call the function as an instance method of the client
                     output = func(**params)
                 else:
                     # For standalone functions, call with client as first argument
                     output = func(client, **params)
+            except ValidationError as e:
+                print_validation_error(e)
+                return
+
             except TypeError as e:
                 # Handle parameter mismatch errors
                 print(f"Error calling function: {e}")
@@ -251,7 +338,7 @@ def execute_format_set_action(
             return
         else:
             # For TABLE output, add output_format to params
-            params['output_format'] = "DICT"
+            params['output_format'] = "TABLE"
             print(f"\n==> Calling function: {func} with parameters:{params}")
             # Call the function and create a table
             try:
@@ -295,9 +382,9 @@ def execute_format_set_action(
                     return
 
                 # Sort the results by display_name if available
-                if "display_name" in result[0]:
+                if result[0].get("display_name", None):
                     sorted_results = sorted(result, key=lambda k: k.get("display_name", ""))
-                elif "Display Name" in result[0]:
+                elif result[0].get("Display Name", None):
                     sorted_results = sorted(result, key=lambda k: k.get("Display Name", ""))
                 else:
                     sorted_results = result
@@ -305,7 +392,10 @@ def execute_format_set_action(
                 # Add columns dynamically based on the first result
                 column_headings = list(sorted_results[0].keys())
                 for heading in column_headings:
-                    table.add_column(heading, justify="left", style="cyan")
+                    if heading == "Usage":
+                        table.add_column(heading, justify="left", style="cyan")
+                    else:
+                        table.add_column(heading, justify="left", style="cyan")
 
                 # Add rows
                 for item in sorted_results:
@@ -342,25 +432,25 @@ def main():
     # First, parse just the format-set argument to determine which other arguments to add
     logger.enable("pyegeria")
     initial_parser = argparse.ArgumentParser(add_help=False)
-    initial_parser.add_argument("--format-set", help="Name of the output format set", required=True)
+    initial_parser.add_argument("--report", help="Name of the report spec", required=True)
     initial_args, _ = initial_parser.parse_known_args()
 
-    # Get the format set to determine user_params
-    format_set_name = initial_args.format_set
-    format_set = select_output_format_set(format_set_name, "ANY")
+    # Get the format set to determine parameters
+    format_set_name = initial_args.report
+    format_set = select_report_format(format_set_name, "ANY")
 
     # Check if the format set exists
     if not format_set:
-        print(f"Error: Format set for '{format_set_name}' not found.")
-        print("Available format sets:")
-        from pyegeria._output_formats import output_format_set_list
-        for name in output_format_set_list():
+        print(f"Error: Report Spec for '{format_set_name}' not found.")
+        print("Available Report Specs:")
+        from pyegeria.view.base_report_formats import report_spec_list
+        for name in report_spec_list():
             print(f"  - {name}")
         return
     
     # Create the full parser with all arguments
-    parser = argparse.ArgumentParser(description="Execute an action from an output format set")
-    parser.add_argument("--format-set", help="Name of the output format set", required=True)
+    parser = argparse.ArgumentParser(description="Execute an action from Report Spec")
+    parser.add_argument("--report", help="Name of the report spec", required=True)
     parser.add_argument("--server", help="Name of the server to connect to")
     parser.add_argument("--url", help="URL Platform to connect to")
     parser.add_argument("--userid", help="User Id")
@@ -370,16 +460,18 @@ def main():
 
 
 
-    # Add arguments based on the format set's user_params
-    user_params = []
+    # Add arguments based on the format set's required/optional params
+    required_params = []
+    optional_params = []
     if "action" in format_set:
         action = format_set["action"]
-        user_params = action.get("user_params", [])
+        required_params = action.get("required_params", action.get("user_params", []))
+        optional_params = action.get("optional_params", [])
         
-        for param in user_params:
+        for param in sorted(set(required_params + optional_params)):
             parser.add_argument(f"--{param.replace('_', '-')}", help=f"{param.replace('_', ' ')} parameter")
     else:
-        print(f"Error: Format set '{format_set_name}' does not have an action property.")
+        print(f"Error: Report Spec '{format_set_name}' does not have an action property.")
         return
     
     args = parser.parse_args()
@@ -391,13 +483,13 @@ def main():
     print(f"root path: {app_config.pyegeria_root}, config_file: {app_config.pyegeria_config_file}")
     userid = args.userid if args.userid is not None else EGERIA_USER
     user_pass = args.password if args.password is not None else EGERIA_USER_PASSWORD
-    format_set_name = args.format_set
+    format_set_name = args.report
     output_format = args.output_format
 
     logger.info(f"view server @ {url}")
-    # Collect all user parameters from args
+    # Collect all parameters from args
     kwargs = {}
-    for param in user_params:
+    for param in sorted(set(required_params + optional_params)):
         arg_name = param.replace('_', '-')
         if hasattr(args, arg_name) and getattr(args, arg_name) is not None:
             kwargs[param] = getattr(args, arg_name)
@@ -406,7 +498,7 @@ def main():
     
     try:
         # If a required parameter is not provided, prompt for it
-        for param in user_params:
+        for param in required_params:
             if param not in kwargs:
                 default_value = "*" if param == "search_string" else ""
                 prompt_text = f"Enter {param.replace('_', ' ')}:"
@@ -414,7 +506,7 @@ def main():
                     prompt_text += f" (default: {default_value})"
                 value = Prompt.ask(prompt_text, default=default_value).strip()
                 kwargs[param] = value
-        print(f"Using format set {format_set_name} and output format {output_format} with parameters: {kwargs} ")
+        print(f"Using Report Spec {format_set_name} and output format {output_format} with parameters: {kwargs} ")
         execute_format_set_action(
             format_set_name=format_set_name,
             view_server=server,