pyegeria 5.4.0.2__py3-none-any.whl → 5.4.0.4__py3-none-any.whl

commands/cli/egeria_cat.py

@@ -13,7 +13,9 @@ import os
 
 import click
 from trogon import tui
+from pyegeria import config_logging, get_app_config
 
+from commands.cat.list_format_set import execute_format_set_action
 from commands.cat.dr_egeria_md import process_markdown_file
 from commands.cat.get_asset_graph import asset_viewer
 from commands.cat.get_collection import collection_viewer
@@ -58,110 +60,109 @@ from commands.my.todo_actions import (
     )
 from commands.tech.list_asset_types import display_asset_types
 
+EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
+EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
+app_settings = get_app_config()
+app_config = app_settings["Environment"]
+# config_logging()
+
 
 # @tui
 # @tui('menu','menu','A textual object_action line interface')
 @tui()
-@click.version_option("0.0.1", prog_name="egeria_ops")
+# @tui('menu', 'menu', 'A textual object_action line interface')
+@click.version_option("5.4 ", prog_name="hey_egeria")
 @click.group()
 @click.option(
     "--server",
-    default=os.environ.get("EGERIA_METADATA_STORE", "qs-metadata-store"),
+    default=app_config['Egeria Metadata Store'],
     help="Egeria metadata store to work with",
 )
 @click.option(
     "--url",
-    default=os.environ.get("EGERIA_PLATFORM_URL", "https://localhost:9443"),
+    default=app_config["Egeria Platform URL"],
     help="URL of Egeria metadata store platform to connect to",
 )
 @click.option(
     "--integration_daemon",
-    default=os.environ.get("EGERIA_INTEGRATION_DAEMON", "qs-integration-daemon"),
+    default=app_config["Egeria Integration Daemon"],
     help="Egeria integration daemon to work with",
 )
 @click.option(
     "--integration_daemon_url",
-    default=os.environ.get("EGERIA_INTEGRATION_DAEMON_URL", "https://localhost:9443"),
+    default=app_config['Egeria Integration Daemon URL'],
     help="URL of Egeria integration daemon platform to connect to",
 )
 @click.option(
     "--view_server",
-    default=os.environ.get("EGERIA_VIEW_SERVER", "qs-view-server"),
+    default=app_config['Egeria View Server'],
     help="Egeria view server to work with",
 )
 @click.option(
     "--view_server_url",
-    default=os.environ.get("EGERIA_VIEW_SERVER_URL", "https://localhost:9443"),
+    default=app_config['Egeria View Server URL'],
     help="URL of Egeria view server platform to connect to",
 )
 @click.option(
     "--engine_host",
-    default=os.environ.get("EGERIA_ENGINE_HOST", "qs-engine-host"),
+    default=app_config['Egeria Engine Host'],
     help="Egeria engine host to work with",
 )
 @click.option(
     "--engine_host_url",
-    default=os.environ.get("EGERIA_ENGINE_HOST_URL", "https://localhost:9443"),
+    default=app_config['Egeria Engine Host URL'],
     help="URL of Egeria engine host platform to connect to",
 )
-@click.option(
-    "--admin_user",
-    default=os.environ.get("EGERIA_ADMIN_USER", "garygeeke"),
-    help="Egeria admin user",
-)
-@click.option(
-    "--admin_user_password",
-    default=os.environ.get("EGERIA_ADMIN_PASSWORD", "secret"),
-    help="Egeria admin password",
-)
+
 @click.option(
     "--userid",
-    default=os.environ.get("EGERIA_USER", "peterprofile"),
+    default=EGERIA_USER,
     help="Egeria user",
 )
 @click.option(
     "--password",
-    default=os.environ.get("EGERIA_USER_PASSWORD", "secret"),
+    default=EGERIA_USER_PASSWORD,
     help="Egeria user password",
 )
 @click.option("--timeout", default=60, help="Number of seconds to wait")
 @click.option(
     "--jupyter",
     is_flag=True,
-    default=os.environ.get("EGERIA_JUPYTER", "False"),
+    type=bool,
+    default=app_config['Egeria Jupyter'],
     help="Enable for rendering in a Jupyter terminal",
 )
 @click.option(
     "--width",
-    default=os.environ.get("EGERIA_WIDTH", 200),
+    default=app_config['Console Width'],
     type=int,
     help="Screen width, in characters, to use",
 )
 @click.option(
     "--home_glossary_guid",
-    default=os.environ.get("EGERIA_HOME_GLOSSARY_GUID", None),
-    help="Glossary guid to use as the home glossary",
+    default=app_settings['User Profile']['Egeria Home Glossary Name'],
+    help="Glossary name to use as the home glossary",
 )
 @click.option(
     "--glossary_path",
-    default=os.environ.get("EGERIA_GLOSSARY_PATH", "/home/jovyan/loading-bay/glossary"),
+    default=app_config['Egeria Glossary Path'],
     help="Path to glossary import/export files",
 )
 
 @click.option(
     "--root_path",
-    default=os.environ.get("EGERIA_ROOT_PATH", "/home/jovyan"),
+    default=app_config['Pyegeria Root'],
     help="Root path to use for file operations",
 )
 
 @click.option(
     "--inbox_path",
-    default=os.environ.get("EGERIA_INBOX_PATH", "loading-bay/dr_egeria_inbox"),
+    default=app_config['Dr.Egeria Inbox'],
     help="Path to inbox files",
 )
 @click.option(
     "--outbox_path",
-    default=os.environ.get("EGERIA_OUTBOX_PATH", "distribution-hub/dr_egeria_outbox"),
+    default=app_config['Dr.Egeria Outbox'],
     help="Path to outbox files",
 )
 
@@ -176,8 +177,6 @@ def cli(
     integration_daemon_url,
     engine_host,
     engine_host_url,
-    admin_user,
-    admin_user_password,
     userid,
     password,
     timeout,
@@ -199,8 +198,6 @@ def cli(
         integration_daemon_url,
         engine_host,
         engine_host_url,
-        admin_user,
-        admin_user_password,
         userid,
         password,
         timeout,
@@ -229,6 +226,22 @@ def info(ctx):
     pass
 
 
+@info.command("list-output-set")
+@click.option("--format-set", help="Format set to output")
+@click.option("--output-format", default = "TABLE", help="Output format type")
+@click.option('--search-string', default="*", help="Search string")
+@click.pass_context
+def show_format_set(ctx, format_set, output_format, search_string):
+    """Dynamically generate output based on a format set"""
+    c = ctx.obj
+
+    execute_format_set_action(
+        format_set, c.view_server, c.view_server_url,
+        c.userid, c.password, output_format, search_string = search_string
+    )
+
+
+
 @info.command("tech-types")
 @click.option("--tech_type", default="*", help="Tech type to search for")
 @click.pass_context

commands/cli/ops_config.py

@@ -12,8 +12,6 @@ class Config(object):
         integration_daemon_url: str,
         engine_host: str,
         engine_host_url: str,
-        admin_user: str,
-        admin_user_password: str,
         userid: str,
         password: str,
         timeout: int,
@@ -33,8 +31,7 @@ class Config(object):
         self.integration_daemon_url = integration_daemon_url
         self.engine_host = engine_host
         self.engine_host_url = engine_host_url
-        self.admin_user = admin_user
-        self.admin_user_password = admin_user_password
+
         self.userid = userid
         self.password = password
         self.timeout = timeout

md_processing/dr-egeria-outbox/DataStruct-2025-07-29-20-49-16.py

@@ -0,0 +1,8 @@
+[
+    {
+        "Display Name": "",
+        "Qualified Name": " [DataStruct::TBDF-Incoming Weekly Measurement Data](#3e4bc9a1-2661-4d24-a753-b26060c61e34) ",
+        "Category": "",
+        "Description": "This describes the weekly measurement data for each patient for the Teddy Bear drop foot clinical trial."
+    }
+]

md_processing/dr-egeria-outbox/Mandy-DataStruct-2025-07-29-15-54-45.md

@@ -0,0 +1,19 @@
+# Puddy Approves
+This is a tutorial on how to use a data struct description
+
+# Data Structure Report - created at 2025-07-29 15:54
+	Data Structure  found from the search string:  `All`
+
+<a id="3e4bc9a1-2661-4d24-a753-b26060c61e34"></a>
+# Data Structure Name: 
+
+## Qualified Name
+[DataStruct::TBDF-Incoming Weekly Measurement Data](#3e4bc9a1-2661-4d24-a753-b26060c61e34)
+
+## Description
+This describes the weekly measurement data for each patient for the Teddy Bear drop foot clinical trial.
+
+## GUID
+3e4bc9a1-2661-4d24-a753-b26060c61e34
+
+[[Data Structure]]

pyegeria/_exceptions_new.py

@@ -16,11 +16,9 @@ from rich.table import Table
 from rich.text import Text
 from rich import print, box
 from rich.console import Console
-from pyegeria.load_config import get_app_config
-from pyegeria._exceptions import EgeriaErrorCode
 
-app_settings = get_app_config()
-EGERIA_WIDTH = app_settings.get("console_width", 200)
+
+EGERIA_WIDTH = os.getenv("PYEGERIA_CONSOLE_WIDTH", 200)
 console = Console(width=EGERIA_WIDTH)
 
 """
@@ -313,7 +311,7 @@ def print_exception_response(e: PyegeriaException):
     if isinstance(e, PyegeriaException):
         console.print(Markdown(f"\n---\n# Exception: {e.__class__.__name__}"))
         msg: Text = Text(e.__str__(), overflow="fold")
-        if e.related_http_code:
+        if hasattr(e, 'related_http_code') and e.related_http_code:
             related_response = e.response.json()
             exception_msg_id = related_response.get("exceptionErrorMessageId", None)
             if exception_msg_id:

pyegeria/_output_formats.py

@@ -5,18 +5,24 @@ Copyright Contributors to the ODPi Egeria project.
 
 """
 # Purpose
+This file manages output format sets.
+
 pyegeria allows find and get requests to generate output in different output formats - 
 including DICT, MD, FORM, REPORT, LIST, MERMAID, TABLE, and perhaps additional ones in the future.
 
-Some of the formats, such as REPORT and LIST,  allow the user to filter which attributes to
+Some of the formats, such as REPORT and LIST, allow the user to filter which attributes to
 display, and the order in which they appear. However, many, if not most users will likely not want to customize
 the column list and so we need a sensible set of defaults for each type of output. These defaults are used 
 by the find and get methods if the user doesn't provide a value for the columns parameter.
 
-This file contains these defaults and a function to return the the right default dict for a given type.
-
+This file contains these defaults and a function to return the right default dict for a given type.
 """
 
+from loguru import logger
+
+# Constants
+MD_SEPARATOR = "\n---\n\n"
+
 # Define shared elements
 COMMON_COLUMNS = [
     {'name': 'Display Name', 'key': 'display_name'},
@@ -49,6 +55,11 @@ COLLECTION_DICT = {
         "columns": COLLECTIONS_COLUMNS,
     }
 
+COLLECTION_TABLE = {
+    "types": ["TABLE"],
+    "columns": COMMON_COLUMNS,
+    }
+
 COMMON_ANNOTATIONS = {
     "wikilinks": ["[[Commons]]"]
 }
@@ -85,7 +96,11 @@ output_format_sets = {
         "aliases": ["Collection", "RootCollection", "Folder", "ReferenceList", "HomeCollection",
                     "ResultSet", "RecentAccess", "WorkItemList", "Namespace"],
         "annotations": COMMON_ANNOTATIONS,
-        "formats": [COMMON_FORMATS_ALL, COLLECTION_DICT]  # Reusing common formats
+        "formats": [COMMON_FORMATS_ALL, COLLECTION_DICT, COLLECTION_TABLE], # Reusing common formats
+        "action": [{"function": "CollectionManager.find_collections",
+                   "user_params": [ "search_string"],
+                   "spec_params": {    },
+            }]
     },
 
     "DigitalProducts": {
@@ -107,6 +122,11 @@ output_format_sets = {
                     {'name': 'Members', 'key': 'members', 'format': True},
                 ],
             }
+        ],
+        "action": [{"function": "CollectionManager.find_collections",
+                    "user_params": [ "search_string"],
+                    "spec_params": { "classification_name":"DigitalProducts"}
+                       }
         ]
     },
 
@@ -115,30 +135,63 @@ output_format_sets = {
         "description": "Attributes generic to all Agreements.",
         "aliases": ["DataSharingAgreement"],
         "annotations": {"wikilinks": ["[[Agreements]]", "[[Egeria]]"]},
-        "formats": COMMON_FORMATS_ALL  # Reusing common formats and columns
+        "formats": [COMMON_FORMATS_ALL] # Reusing common formats and columns
     },
 
-    "Data Dictionary": {
+    "DataDictionary": {
         "heading": "Data Dictionary Information",
         "description": "Attributes useful to Data Dictionary.",
-        "aliases": ["Data Dict"],
+        "aliases": ["Data Dict", "Data Dictionary"],
         "annotations": {"wikilinks": ["[[Data Dictionary]]"]},
-        "formats": COMMON_FORMATS_ALL  # Reusing common formats and columns
+        "formats": [COMMON_FORMATS_ALL],  # Reusing common formats and columns
+        "action": [{"function": "CollectionManager.find_collections",
+                   "user_params": [ "search_string"],
+                   "spec_params": { "classification_name": "DataDictionary" },
+            }]
     },
 
     "Data Specification": {
         "heading": "Data Specification Information",
         "description": "Attributes useful to Data Specification.",
-        "aliases": ["Data Spec"],
+        "aliases": ["Data Spec", "DataSpec", "DataSpecification"],
         "annotations": {"wikilinks": ["[[Data Specification]]"]},
-        "formats": COMMON_FORMATS_ALL  # Reusing common formats and columns
+        "formats": [{"types": ["TABLE"], "columns": COMMON_COLUMNS,}],  # Reusing common formats and columns
+        "action": [{"function": "CollectionManager.find_collections",
+                   "user_params": [ "search_string"],
+                   "spec_params": { "classification_name": "DataSpec" },
+            }]
+    },
+    "DataStruct": {
+        "heading": "Data Structure Information",
+        "description": "Attributes useful to Data Structures.",
+        "aliases": ["Data Structure", "DataStructures", "Data Structures", "Data Struct", "DataStructure"],
+        "annotations": {"wikilinks": ["[[Data Structure]]"]},
+        "formats": [{"types": ["ALL"], "columns" : COMMON_COLUMNS}],  # Reusing common formats and columns
+        "action": [{"function": "DataDesigner.find_data_structures",
+                   "user_params": ["search_string" ],
+                   "spec_params": {  },
+            }]
     },
+    "Mandy-DataStruct": {
+        "heading": "Puddy Approves",
+        "description": "This is a tutorial on how to use a data struct description",
+        "aliases": [],
+        "annotations": {"wikilinks": ["[[Data Structure]]"]},
+        "formats": [{"types": ["TABLE"], "columns":  COMMON_COLUMNS + [{'name': 'GUID', 'key': 'GUID'}]},
+                    { "types": ["DICT", "LIST", "REPORT"], "columns": COMMON_COLUMNS + [{'name': 'GUID', 'key': 'GUID'}]}
+                    ],
+        "action": [{
+                       "function": "DataDesigner.find_data_structures",
+                       "user_params": ["filter"],
+                       "spec_params": {},
+                       }]
+        },
 }
 
-
 def select_output_format_set(kind: str, output_type: str) -> dict | None:
     """
     This function retrieves the appropriate output set configuration dictionary based on the `kind` and `output_type`.
+    If output_type = `ANY` that indicates this is just a test to see of the output format set exists.
 
     :param kind: The kind of output set (e.g., "Referenceable", "Collections").
     :param output_type: The desired output format type (e.g., "DICT", "LIST", "REPORT").
@@ -147,17 +200,14 @@ def select_output_format_set(kind: str, output_type: str) -> dict | None:
     Returns:
         dict | None: 
     """
-    from loguru import logger
-    # from pyegeria.logging_configuration import config_logging
-
-    # config_logging()
-
     # Normalize the output type to uppercase for consistency
+    output_sets = output_format_sets
+
     output_type = output_type.upper()
     output_struct:dict = {}
 
     # Step 1: Check if `kind` exists in the `output_format_sets` dictionary
-    element = output_format_sets.get(kind)
+    element = output_sets.get(kind)
 
     # Step 2: If not found, attempt to match `kind` in aliases
     if element is None:
@@ -170,7 +220,7 @@ def select_output_format_set(kind: str, output_type: str) -> dict | None:
 
     # Step 3: If still not found, return None
     if element is None:
-        msg = "No matching column set found for kind='{kind}' and output type='{output_type}'."
+        msg = f"No matching column set found for kind='{kind}' and output type='{output_type}'."
         logger.error(msg)
         return None
     else:
@@ -178,6 +228,12 @@ def select_output_format_set(kind: str, output_type: str) -> dict | None:
         output_struct["heading"] = element.get("heading", [])
         output_struct["description"] = element.get("description", [])
         output_struct["annotations"] = element.get("annotations", {})
+        if "action" in element:
+            output_struct["action"] = element.get("action", [])
+
+    # If this was just a validation that the format set could be found then the output type is ANY - so just return.
+    if output_type == "ANY":
+        return output_struct
 
     # Step 4: Search for a matching format in the `formats` list
     for format in element.get("formats", []):
@@ -193,4 +249,12 @@ def select_output_format_set(kind: str, output_type: str) -> dict | None:
 
     # Step 6: If no match is found, return None
     logger.error(f"No matching format found for kind='{kind}' with output type='{output_type}'.")
-    return None
+    return None
+
+def output_format_set_list()->list[str]:
+    return list(output_format_sets.keys())
+
+def get_output_format_set_heading(format_set: str) -> str:
+    return output_format_sets[format_set].get("heading")
+def get_output_format_set_description(format_set: str) -> str:
+    return output_format_sets[format_set].get("description")

pyegeria/collection_manager_omvs.py

@@ -11,7 +11,7 @@ from typing import Dict, Union, List, Optional
 
 from loguru import logger
 
-from pyegeria import select_output_format_set
+from pyegeria._output_formats import select_output_format_set
 from pyegeria._client import Client
 from pyegeria._globals import NO_ELEMENTS_FOUND, NO_GUID_RETURNED, NO_MEMBERS_FOUND
 from pyegeria._validators import validate_guid, validate_search_string

pyegeria/data_designer_omvs.py

@@ -11,9 +11,10 @@ import asyncio
 from os import terminal_size
 
 from httpx import Response
+from loguru import logger
 from prompt_toolkit import data_structures
 
-from pyegeria import select_output_format_set
+from pyegeria._output_formats import select_output_format_set
 from pyegeria._client import Client, max_paging_size
 from pyegeria._globals import NO_ELEMENTS_FOUND
 from pyegeria.output_formatter import (extract_mermaid_only, extract_basic_dict, generate_output,
@@ -1328,15 +1329,15 @@ r       replace_all_properties: bool, default = False
                                                     output_format, columns_struct))
         return response
 
-    async def _async_find_data_structures(self, filter: str, start_from: int = 0, page_size: int = max_paging_size,
+    async def _async_find_data_structures(self, search_string: str, start_from: int = 0, page_size: int = max_paging_size,
                                           starts_with: bool = True, ends_with: bool = False, ignore_case: bool = True,
-                                          output_format: str = 'JSON',  columns_struct: dict = None) -> list | str:
+                                          output_format: str = 'JSON',  output_format_set: str|dict = None) -> list | str:
         """ Find the list of data structure metadata elements that contain the search string.
             Async version.
 
         Parameters
         ----------
-        filter: str
+        search_string: str
             - search string to filter on.
         start_from: int, default = 0
             - index of the list to start from (0 for start).
@@ -1350,7 +1351,7 @@ r       replace_all_properties: bool, default = False
             - If True, the case of the search string is ignored.
         output_format: str, default = "DICT"
             - one of "DICT", "MERMAID" or "JSON"
-        columns_struct: dict, optional, default = None
+        output_format_set: dict|str, optional, default = None
             - The desired output columns/field options.
         Returns
         -------
@@ -1367,10 +1368,10 @@ r       replace_all_properties: bool, default = False
             the requesting user is not authorized to issue this request.
 
         """
-        if filter == "*":
-            filter = None
+        if search_string == "*":
+            search_string = None
 
-        body = {"filter": filter}
+        body = {"filter": search_string}
         starts_with_s = str(starts_with).lower()
         ends_with_s = str(ends_with).lower()
         ignore_case_s = str(ignore_case).lower()
@@ -1379,8 +1380,6 @@ r       replace_all_properties: bool, default = False
             [("startFrom", start_from), ("pageSize", page_size), ("startsWith", ends_with_s), ("endsWith", ends_with_s),
              ("ignoreCase", ignore_case_s),])
 
-
-
         url = (f"{base_path(self, self.view_server)}/data-structures/by-search-string"
                f"{possible_query_params}")
 
@@ -1391,17 +1390,17 @@ r       replace_all_properties: bool, default = False
             return NO_ELEMENTS_FOUND
 
         if output_format != 'JSON':  # return a simplified markdown representation
-            return self._generate_data_structure_output(elements, filter, output_format, columns_struct)
+            return self._generate_data_structure_output(elements, filter, output_format, output_format_set)
         return elements
 
-    def find_data_structures(self, filter: str, start_from: int = 0, page_size: int = max_paging_size,
+    def find_data_structures(self, search_string: str, start_from: int = 0, page_size: int = max_paging_size,
                              starts_with: bool = True, ends_with: bool = False, ignore_case: bool = True,
-                             output_format: str = 'JSON',  columns_struct: dict = None) -> list | str:
+                             output_format: str = 'JSON',  output_format_set:str| dict = None) -> list | str:
         """ Retrieve the list of data structure metadata elements that contain the search string filter.
 
         Parameters
         ----------
-        filter: str
+        search_string: str
             - search string to filter on.
         start_from: int, default = 0
             - index of the list to start from (0 for start).
@@ -1416,7 +1415,7 @@ r       replace_all_properties: bool, default = False
         output_format: str, default = "DICT"
             output_format: str, default = "DICT"
             -  one of "DICT", "MERMAID" or "JSON"
-        columns_struct: dict, optional, default = None
+        output_format_set: dict|str, optional, default = None
             - The desired output columns/field options.
 
         Returns
@@ -1438,8 +1437,8 @@ r       replace_all_properties: bool, default = False
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_find_data_structures(filter, start_from, page_size, starts_with, ends_with, ignore_case,
-                                             output_format, columns_struct))
+            self._async_find_data_structures(search_string, start_from, page_size, starts_with, ends_with, ignore_case,
+                                             output_format, output_format_set))
         return response
 
     async def _async_get_data_structures_by_name(self, filter: str, body: dict = None, start_from: int = 0,
@@ -5381,7 +5380,7 @@ r       replace_all_properties: bool, default = False
                                    )
 
 
-    def _generate_data_structure_output(self, elements, filter, output_format, columns_struct)  -> str | list:
+    def _generate_data_structure_output(self, elements, filter, output_format: str = "DICT", output_format_set: str|dict = None)  -> str | list:
         """
         Generate output for data structures in the specified format.
 
@@ -5394,17 +5393,24 @@ r       replace_all_properties: bool, default = False
             Formatted output as string or list of dictionaries
         """
         entity_type = "Data Structure"
-        if columns_struct is None:
-            columns_struct = select_output_format_set(entity_type, output_format)
-
-
+        if output_format_set is None:
+            output_format_set = select_output_format_set(entity_type, output_format)
+
+        if output_format_set:
+            if isinstance(output_format_set, str):
+                output_formats = select_output_format_set(output_format_set, output_format)
+            if isinstance(output_format_set, dict):
+                output_formats = output_format_set
+        else:
+            output_formats = None
+        logger.trace(f"Executing generate_data_structure_output for {entity_type}: {output_formats}")
         return generate_output(elements,
                                filter,
                                entity_type,
                                output_format,
                                self._extract_data_structure_properties,
                                None,
-                               columns_struct,
+                               output_formats,
                                )
 
     def _generate_data_class_output(self, elements: dict, filter: str, output_format: str, columns_struct: dict = None)  -> str | list: