pyegeria 5.4.0.4__tar.gz → 5.4.0.5__tar.gz

{pyegeria-5.4.0.4 → pyegeria-5.4.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyegeria
-Version: 5.4.0.4
+Version: 5.4.0.5
 Summary: A python client for Egeria
 License: Apache 2.0
 Keywords: egeria,metadata,governance
@@ -22,6 +22,7 @@ Requires-Dist: mermaid-py
 Requires-Dist: poetry-core (>=2.1.3,<3.0.0)
 Requires-Dist: psycopg2-binary (>=2.9.9,<3.0.0)
 Requires-Dist: pydantic (>=2.11.7,<3.0.0)
+Requires-Dist: pydantic-settings (>=2.10.1,<3.0.0)
 Requires-Dist: pytest (>=8.3.5,<9.0.0)
 Requires-Dist: requests
 Requires-Dist: rich

{pyegeria-5.4.0.4 → pyegeria-5.4.0.5}/commands/cat/list_collections.py

@@ -16,52 +16,44 @@ from rich.markdown import Markdown
 from rich.prompt import Prompt
 from rich.table import Table
 from rich.text import Text
-
+from loguru import logger
 from pyegeria import (
-    # EgeriaTech,
-    # InvalidParameterException,
-    # PropertyServerException,
-    # UserNotAuthorizedException,
     CollectionManager,
-     NO_ELEMENTS_FOUND,config_logging, get_app_config
+     NO_ELEMENTS_FOUND,config_logging, get_app_config, init_logging
     )
 from pyegeria._exceptions_new import PyegeriaException, print_exception_response
 
-
-
-# disable_ssl_warnings = True
-
-# EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
-# EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9092")
-# EGERIA_PLATFORM_URL = os.environ.get("EGERIA_PLATFORM_URL", "https://localhost:9443")
-# EGERIA_VIEW_SERVER = os.environ.get("EGERIA_VIEW_SERVER", "view-server")
-# EGERIA_VIEW_SERVER_URL = os.environ.get(
-#     "EGERIA_VIEW_SERVER_URL", "https://localhost:9443"
-# )
-# EGERIA_INTEGRATION_DAEMON = os.environ.get("EGERIA_INTEGRATION_DAEMON", "integration-daemon")
-# EGERIA_ADMIN_USER = os.environ.get("ADMIN_USER", "garygeeke")
-# EGERIA_ADMIN_PASSWORD = os.environ.get("ADMIN_PASSWORD", "secret")
 EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
 EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
-# EGERIA_JUPYTER = bool(os.environ.get("EGERIA_JUPYTER", "False"))
-# EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "200"))
-# EGERIA_GLOSSARY_PATH = os.environ.get("EGERIA_GLOSSARY_PATH", None)
-# EGERIA_ROOT_PATH = os.environ.get("EGERIA_ROOT_PATH", "../../")
-# EGERIA_INBOX_PATH = os.environ.get("EGERIA_INBOX_PATH", "md_processing/dr_egeria_inbox")
-# EGERIA_OUTBOX_PATH = os.environ.get("EGERIA_OUTBOX_PATH", "md_processing/dr_egeria_outbox")
-app_settings = get_app_config()
-app_config = app_settings["Environment"]
+PYEGERIA_ROOT_PATH= os.environ.get("PYEGERIA_ROOT_PATH", "/Users/dwolfson/localGit/egeria-v5-3/egeria-python")
+app_settings = get_app_config(PYEGERIA_ROOT_PATH+"/.env")
+app_config = app_settings.Environment
 config_logging()
 
+out_struct = {
+            "formats": {
+                "types": ["ALL"],
+                "columns": [
+                    {'name': 'display_name', 'key': 'display_name'},
+                    {'name': 'qualified_name', 'key': 'qualified_name', 'format': True},
+                    {'name': 'description', 'key': 'description', 'format': True},
+                    {'name': "classifications", 'key': 'classifications'},
+                    {'name': 'members', 'key': 'members', 'format': True},
+                    {'name': 'collection_type', 'key': 'collection_type', 'format': True},
+                    {'name': 'GUID', 'key': 'GUID'},
+                ],
+            },
+
+        }
 
 def display_collections(
     search_string: str = "*",
-    view_server: str = app_config['Egeria View Server'],
-    view_url: str = app_config['Egeria View Server URL'],
-    user: str = EGERIA_USER,
-    user_pass: str = EGERIA_USER_PASSWORD,
-    jupyter: bool = app_config['Egeria Jupyter'],
-    width: int = app_config['Console Width'],
+    view_server: str = app_config.egeria_view_server,
+    view_url: str = app_config.egeria_view_server_url,
+    user: str = app_settings.User_Profile.user_name,
+    user_pass: str = app_settings.User_Profile.user_pwd,
+    jupyter: bool = app_config.egeria_jupyter,
+    width: int = app_config.console_width,
     output_format: str = "TABLE"
 ):
     """Display either a specified glossary or all collections if the search_string is '*'.
@@ -144,9 +136,10 @@ def display_collections(
 
         collections = m_client.find_collections(
             search_string.strip(), None, True, False, ignore_case=True,
-            output_format = "DICT"
+            output_format = "DICT", output_format_set=out_struct
         )
         if type(collections) is list:
+
             sorted_collection_list = sorted(
                 collections, key=lambda k: k["display_name"]
             )
@@ -203,13 +196,13 @@ def main():
     parser.add_argument("--password", help="User Password")
 
     args = parser.parse_args()
-    app_settings = get_app_config()
-    app_config = app_settings["Environment"]
+    # app_settings = get_app_config(PYEGERIA_ROOT_PATH + "/.env")
+    # app_config = app_settings.Environment
 
-    server = args.server if args.server is not None else app_config['Egeria View Server']
-    url = args.url if args.url is not None else app_config['Egeria View Server URL']
-    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
+    server = args.server if args.server is not None else app_config.egeria_view_server
+    url = args.url if args.url is not None else app_config.egeria_view_server_url
+    userid = args.userid if args.userid is not None else app_settings.User_Profile.user_name
+    user_pass = args.password if args.password is not None else app_settings.User_Profile.user_pwd
 
     try:
         search_string = Prompt.ask(
@@ -227,4 +220,7 @@ def main():
 
 
 if __name__ == "__main__":
+    # EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
+    # EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
+    # PYEGERIA_ROOT_PATH = os.environ.get("PYEGERIA_ROOT_PATH", "/Users/dwolfson/localGit/egeria-v5-3/egeria-python")
     main()

{pyegeria-5.4.0.4 → pyegeria-5.4.0.5}/commands/cat/list_format_set.py

@@ -61,7 +61,7 @@ from pyegeria.egeria_tech_client import EgeriaTech
 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"]
+app_config = app_settings.Environment
 config_logging()
 
 console = Console(
@@ -72,10 +72,10 @@ console = Console(
 
 def execute_format_set_action(
     format_set_name: str,
-    view_server: str = app_config['Egeria View Server'],
-    view_url: str = app_config['Egeria View Server URL'],
-    user: str = EGERIA_USER,
-    user_pass: str = EGERIA_USER_PASSWORD,
+    view_server: str = app_config.egeria_view_server,
+    view_url: str = app_config.egeria_view_server_url,
+    user: str = app_settings.User_Profile.user_name,
+    user_pass: str = app_settings.User_Profile.user_pwd,
     output_format: str = "TABLE",
     **kwargs
 ):
@@ -225,7 +225,7 @@ def execute_format_set_action(
 
             with open(full_file_path, 'w') as f:
                 f.write(output)
-            print(f"\n==> Output written to {full_file_path}")
+            print(f"\n==> Output written to [{format_set_name}]({full_file_path})")
             return
 
         # For TABLE output, add output_format to params

{pyegeria-5.4.0.4 → pyegeria-5.4.0.5}/pyegeria/__init__.py

@@ -11,7 +11,7 @@ the server platform and servers.
 
 """
 from .load_config import load_app_config, get_app_config
-from .logging_configuration import config_logging
+from .logging_configuration import config_logging, init_logging
 from ._globals import (INTEGRATION_GUIDS, TEMPLATE_GUIDS, default_time_out, disable_ssl_warnings, enable_ssl_check,
                        is_debug, max_paging_size, NO_ELEMENTS_FOUND, NO_ASSETS_FOUND, NO_SERVERS_FOUND,
                        NO_CATALOGS_FOUND, NO_GLOSSARIES_FOUND, NO_TERMS_FOUND, NO_CATEGORIES_FOUND, NO_ELEMENT_FOUND,

{pyegeria-5.4.0.4 → pyegeria-5.4.0.5}/pyegeria/_exceptions_new.py

@@ -360,3 +360,32 @@ def print_exception_table(e: PyegeriaException):
         console.print(table)
     else:
         print(f"\n\n\t  Not an Pyegeria exception {e}")
+
+def print_basic_exception(e: PyegeriaException):
+    """Prints the exception response"""
+    related_code = e.related_http_code if hasattr(e, "related_http_code") else ""
+    related_response = e.response.json()
+    table = Table(title=f"Exception: {e.__class__.__name__}", show_lines=True, header_style="bold", box=box.HEAVY_HEAD)
+    table.caption = e.pyegeria_code
+    table.add_column("Facet", justify="center")
+    table.add_column("Item", justify="left", width=80)
+
+    if isinstance(e, PyegeriaException):
+        table.add_row("HTTP Code", str(e.response_code))
+        table.add_row("Egeria Code", str(related_code))
+        table.add_row("Caller Method", e.context.get("caller method", "---"))
+        table.add_row("Request URL", str(e.response_url))
+        table.add_row("Egeria Message",
+                      format_dict_to_string(related_response.get('exceptionErrorMessage',"")))
+        table.add_row("Egeria User Action",
+                      format_dict_to_string(related_response.get('exceptionUserAction',"")))
+
+        exception_msg_id = related_response.get("exceptionErrorMessageId", None)
+        table.add_row("Pyegeria Exception", exception_msg_id)
+        table.add_row("Pyegeria Message",
+                      f"\n\t{e.error_details['message_template'].format(exception_msg_id)}\n")
+
+
+        console.print(table)
+    else:
+        print(f"\n\n\t  Not an Pyegeria exception {e}")

{pyegeria-5.4.0.4 → pyegeria-5.4.0.5}/pyegeria/_output_formats.py

@@ -96,7 +96,7 @@ output_format_sets = {
         "aliases": ["Collection", "RootCollection", "Folder", "ReferenceList", "HomeCollection",
                     "ResultSet", "RecentAccess", "WorkItemList", "Namespace"],
         "annotations": COMMON_ANNOTATIONS,
-        "formats": [COMMON_FORMATS_ALL, COLLECTION_DICT, COLLECTION_TABLE], # Reusing common formats
+        "formats": [ COLLECTION_DICT, COLLECTION_TABLE,COMMON_FORMATS_ALL], # Reusing common formats
         "action": [{"function": "CollectionManager.find_collections",
                    "user_params": [ "search_string"],
                    "spec_params": {    },
@@ -155,7 +155,7 @@ output_format_sets = {
         "description": "Attributes useful to Data Specification.",
         "aliases": ["Data Spec", "DataSpec", "DataSpecification"],
         "annotations": {"wikilinks": ["[[Data Specification]]"]},
-        "formats": [{"types": ["TABLE"], "columns": COMMON_COLUMNS,}],  # Reusing common formats and columns
+        "formats": [{"types": ["DICT"], "columns": COMMON_COLUMNS,}],  # Reusing common formats and columns
         "action": [{"function": "CollectionManager.find_collections",
                    "user_params": [ "search_string"],
                    "spec_params": { "classification_name": "DataSpec" },
@@ -172,6 +172,17 @@ output_format_sets = {
                    "spec_params": {  },
             }]
     },
+"DataField": {
+        "heading": "Data Structure Information",
+        "description": "Attributes useful to Data Structures.",
+        "aliases": ["Data Field", "Data Fields", "DataFields"],
+        "annotations": {"wikilinks": ["[[Data Field]]"]},
+        "formats": [{"types": ["ALL"], "columns" : COMMON_COLUMNS}],  # Reusing common formats and columns
+        "action": [{"function": "DataDesigner.find_data_fields",
+                   "user_params": ["search_string" ],
+                   "spec_params": {  },
+            }]
+    },
     "Mandy-DataStruct": {
         "heading": "Puddy Approves",
         "description": "This is a tutorial on how to use a data struct description",
@@ -254,7 +265,22 @@ def select_output_format_set(kind: str, output_type: str) -> dict | None:
 def output_format_set_list()->list[str]:
     return list(output_format_sets.keys())
 
-def get_output_format_set_heading(format_set: str) -> str:
+def get_output_format_set_heading(format_set: dict) -> str:
     return output_format_sets[format_set].get("heading")
-def get_output_format_set_description(format_set: str) -> str:
+def get_output_format_set_description(format_set: dict) -> str:
     return output_format_sets[format_set].get("description")
+
+def get_output_format_type_match(format_set: dict, output_format: str) -> dict:
+    if isinstance(format_set, list):
+        for format in format_set.get("formats", []):
+            if output_format in format.get("types", []):
+                format_set["formats"] = format
+                return format_set
+
+        # Step 5: Handle the fallback case of "ALL"
+        for format in format_set.get("formats", []):
+            if "ALL" in format.get("types", []):
+                format_set["formats"] = format
+                return format_set
+    else:
+        return format_set

{pyegeria-5.4.0.4 → pyegeria-5.4.0.5}/pyegeria/collection_manager_omvs.py

@@ -11,7 +11,7 @@ from typing import Dict, Union, List, Optional
 
 from loguru import logger
 
-from pyegeria._output_formats import select_output_format_set
+from pyegeria._output_formats import select_output_format_set, get_output_format_type_match
 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
@@ -150,8 +150,8 @@ class CollectionManager(Client2):
 
         if output_format != 'JSON':  # return a simplified markdown representation
             logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self.generate_collection_output(elements, None, None, output_format,
-                                                   output_format_set=output_format_set)
+            return self._generate_collection_output(elements, None, None, output_format,
+                                                    output_format_set=output_format_set)
         return elements
 
 
@@ -303,8 +303,8 @@ class CollectionManager(Client2):
 
         if output_format != 'JSON':  # return a simplified markdown representation
             logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self.generate_collection_output(elements, None, classification_name,
-                                                   output_format, output_format_set)
+            return self._generate_collection_output(elements, None, classification_name,
+                                                    output_format, output_format_set)
         return elements
 
 
@@ -549,8 +549,8 @@ class CollectionManager(Client2):
 
         if output_format != 'JSON':  # return a simplified markdown representation
             logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self.generate_collection_output(elements, filter, classification_name,
-                                                   output_format, output_format_set)
+            return self._generate_collection_output(elements, filter, classification_name,
+                                                    output_format, output_format_set)
         return elements
 
 
@@ -687,8 +687,8 @@ class CollectionManager(Client2):
 
         if output_format != 'JSON':  # return a simplified markdown representation
             logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self.generate_collection_output(elements, filter, collection_type,
-                                                   output_format, output_format_set)
+            return self._generate_collection_output(elements, filter, collection_type,
+                                                    output_format, output_format_set)
         return elements
 
 
@@ -818,8 +818,8 @@ class CollectionManager(Client2):
 
         if output_format != 'JSON':  # return a simplified markdown representation
             logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self.generate_collection_output(elements, None, collection_type,
-                                                   output_format, output_format_set)
+            return self._generate_collection_output(elements, None, collection_type,
+                                                    output_format, output_format_set)
         return elements
 
 
@@ -952,8 +952,8 @@ class CollectionManager(Client2):
 
         if output_format != 'JSON':  # return a simplified markdown representation
             logger.debug(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self.generate_collection_output(elements, None, None,
-                                                   output_format, output_format_set)
+            return self._generate_collection_output(elements, None, None,
+                                                    output_format, output_format_set)
         return elements
 
 
@@ -1091,8 +1091,8 @@ class CollectionManager(Client2):
 
         if output_format != 'JSON':  # return a simplified markdown representation
             logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self.generate_collection_output(elements, None, None,
-                                                   output_format, output_format_set)
+            return self._generate_collection_output(elements, None, None,
+                                                    output_format, output_format_set)
         return elements
 
 
@@ -1218,8 +1218,8 @@ class CollectionManager(Client2):
 
         if output_format != 'JSON':  # return a simplified markdown representation
             logger.info(f"Found elements, output format: {output_format}, output_format_set: {output_format_set}")
-            return self.generate_collection_output(elements, None, None,
-                                                   output_format, output_format_set)
+            return self._generate_collection_output(elements, None, None,
+                                                    output_format, output_format_set)
         return elements
 
 
@@ -6461,9 +6461,9 @@ class CollectionManager(Client2):
         return props
 
 
-    def generate_collection_output(self, elements: Union[Dict, List[Dict]], filter: Optional[str],
-                                   classification_name: Optional[str], output_format: str = "DICT",
-                                   output_format_set: Optional[dict] | str = None) -> Union[str, List[Dict]]:
+    def _generate_collection_output(self, elements: dict|list[dict], filter: Optional[str],
+                                    classification_name: Optional[str], output_format: str = "DICT",
+                                    output_format_set: dict | str = None) -> str| list[dict]:
         """ Generate output for collections in the specified format.
 
             Args:
@@ -6484,15 +6484,16 @@ class CollectionManager(Client2):
         # First see if the user has specified an output_format_set - either a label or a dict
         if output_format_set:
             if isinstance(output_format_set, str):
-                output_formats = select_output_format_set(entity_type, output_format)
+                output_formats = select_output_format_set(output_format_set, output_format)
             if isinstance(output_format_set, dict):
-                output_formats = output_format_set
-
+                output_formats = get_output_format_type_match(output_format_set, output_format)
         # If no output_format was set, then use the classification_name to lookup the output format
         elif classification_name:
             output_formats = select_output_format_set(classification_name, output_format)
         else:
-            output_formats = None
+            # fallback to collections or entity type
+            output_formats = select_output_format_set(entity_type,output_format)
+
         logger.trace(f"Executing generate_collection_output for {entity_type}: {output_formats}")
         return generate_output(
             elements,