pyegeria 5.3.7.7__py3-none-any.whl → 5.3.7.8__py3-none-any.whl

pyegeria/__init__.py

@@ -93,7 +93,8 @@ from .x_action_author_omvs import ActionAuthor
 from .md_processing_utils import (extract_command, process_glossary_upsert_command, process_term_upsert_command,
                                   process_categories_upsert_command,
                                   get_current_datetime_string, process_per_proj_upsert_command, command_list,
-                                  render_markdown, process_provenance_command, process_blueprint_upsert_command)
+                                  render_markdown, process_provenance_command, process_blueprint_upsert_command,
+                                  process_solution_component_upsert_command)
 
 #
 # The following assignments were generated by the `create_tech_guid_lists.py` utility that uses the pyegeria functions

pyegeria/_client.py

@@ -770,7 +770,8 @@ class Client:
         )
         return result
 
-    def __create_qualified_name__(self, type: str, display_name: str, local_qualifier: str = None) -> str:
+    def __create_qualified_name__(self, type: str, display_name: str, local_qualifier: str = None,
+                                  version_identifier: str = None) -> str:
         """Helper function to create a qualified name for a given type and display name.
            If present, the local qualifier will be prepended to the qualified name."""
         EGERIA_LOCAL_QUALIFIER = os.environ.get("EGERIA_LOCAL_QUALIFIER", local_qualifier)
@@ -778,6 +779,8 @@ class Client:
         q_name = f"{type}:{display_name}"
         if EGERIA_LOCAL_QUALIFIER:
             q_name = f"{EGERIA_LOCAL_QUALIFIER}:{q_name}"
+        if version_identifier:
+            q_name = f"{q_name}:{version_identifier}"
         return q_name
 
 if __name__ == "__main__":

pyegeria/commands/cat/dr_egeria_md.py

@@ -13,11 +13,11 @@ import click
 from pyegeria import (extract_command, process_glossary_upsert_command, process_term_upsert_command,
                       process_categories_upsert_command, process_provenance_command,
                       get_current_datetime_string, process_per_proj_upsert_command, command_list,EgeriaTech,
-                      process_blueprint_upsert_command
+                      process_blueprint_upsert_command, process_solution_component_upsert_command,
+                      shared_state
                       )
 from datetime import datetime
 
-
 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")
@@ -86,11 +86,11 @@ def process_markdown_file(
     h1_blocks = []
     current_block = ""
     in_h1_block = False
-    element_dictionary = {}
+
 
     # Helper function to process the current block
     def process_current_block(current_block):
-        nonlocal updated, final_output, prov_found, prov_output, h1_blocks, in_h1_block, element_dictionary
+        nonlocal updated, final_output, prov_found, prov_output, h1_blocks, in_h1_block
 
         if not current_block:
             return  # No block to process
@@ -103,26 +103,30 @@ def process_markdown_file(
                 prov_found = True
 
             elif potential_command in ["Create Glossary", "Update Glossary"]:
-                result = process_glossary_upsert_command(client, element_dictionary, current_block, directive)
+                result = process_glossary_upsert_command(client, shared_state.get_element_dictionary(), current_block, directive)
             elif potential_command in ["Create Category", "Update Category"]:
-                result = process_categories_upsert_command(client, element_dictionary, current_block, directive)
+                result = process_categories_upsert_command(client, shared_state.get_element_dictionary(), current_block, directive)
             elif potential_command in ["Create Term", "Update Term"]:
-                result = process_term_upsert_command(client, element_dictionary, current_block, directive)
+                result = process_term_upsert_command(client, shared_state.get_element_dictionary(), current_block, directive)
             elif potential_command in ["Create Personal Project", "Update Personal Project"]:
-                result = process_per_proj_upsert_command(client, element_dictionary, current_block, directive)
+                result = process_per_proj_upsert_command(client, shared_state.get_element_dictionary(), current_block, directive)
             elif potential_command in ["Create Blueprint", "Update Blueprint", "Create Solution Blueprint", "Update Solution Blueprint"]:
-                result = process_blueprint_upsert_command(client, element_dictionary, current_block, directive)
+                result = process_blueprint_upsert_command(client, shared_state.get_element_dictionary(), current_block, directive)
+            elif potential_command in ["Create Solution Component", "Update Solution Component"]:
+                result = process_solution_component_upsert_command(client, shared_state.get_element_dictionary(), current_block, directive)
+
+
             else:
                 # If command is not recognized, keep the block as-is
                 result = None
-
+            print(json.dumps(shared_state.get_element_dictionary(), indent=4))
             if result:
                 if directive == "process":
                     updated = True
                     final_output.append(result)
-                    # print(json.dumps(element_dictionary, indent=4))
+                    print(json.dumps(shared_state.get_element_dictionary(), indent=4))
                 elif directive == "validate":
-                    print(json.dumps(element_dictionary, indent=4))
+                    print(json.dumps(shared_state.get_element_dictionary(), indent=4))
             elif directive == "process":
                 # Handle errors (skip this block but notify the user)
                 print(f"\n==>\tErrors found while processing command: \'{potential_command}\'\n"

pyegeria/commands/cat/get_project_dependencies.py

@@ -109,7 +109,7 @@ def project_dependency_viewer(
                 child_md = ""
                 child_guid = proj["elementHeader"]["guid"]
                 child_name = proj["properties"]["name"]
-                relationship = proj["relatedElement"]["relationshipHeader"]["type"][
+                relationship = proj["startingElement"]["relationshipHeader"]["type"][
                     "typeName"
                 ]
                 if relationship != "ProjectDependency":

pyegeria/commands/cat/get_project_structure.py

@@ -109,7 +109,7 @@ def project_structure_viewer(
                 child_md = ""
                 child_guid = proj["elementHeader"]["guid"]
                 child_name = proj["properties"]["name"]
-                relationship = proj["relatedElement"]["relationshipHeader"]["type"][
+                relationship = proj["startingElement"]["relationshipHeader"]["type"][
                     "typeName"
                 ]
                 if relationship != "ProjectHierarchy":

pyegeria/glossary_manager_omvs.py

@@ -936,7 +936,7 @@ class GlossaryManager(GlossaryBrowser):
                             continue
 
                 # Add the term
-                term_qualified_name = self.__create_qualified_name__("Term", display_name),
+                term_qualified_name = self.__create_qualified_name__("Term", term_name)
 
                 body = {
                     "class": "ReferenceableRequestBody",

pyegeria/md_processing_helpers.py

@@ -1,68 +1,58 @@
-
-from typing import List, Optional
-
-import os
-import re
-
-from rich import box, print
-from rich.console import Console
-from rich.markdown import Markdown
-
-from pyegeria import body_slimmer
-from pyegeria._globals import NO_TERMS_FOUND, NO_GLOSSARIES_FOUND, NO_TERMS_FOUND, NO_ELEMENTS_FOUND, NO_PROJECTS_FOUND, NO_CATEGORIES_FOUND
-from pyegeria.egeria_tech_client import EgeriaTech
-from pyegeria.md_processing_utils import extract_attribute
-from pyegeria.project_manager_omvs import ProjectManager
-from pyegeria.glossary_manager_omvs import GlossaryManager
-ERROR = "ERROR-> "
-INFO = "INFO- "
-WARNING = "WARNING-> "
-pre_command = "\n---\n==> Processing command:"
-
-
-
-def process_q_name_list(egeria_client: EgeriaTech, element_type:str, txt:str )-> tuple[str,str,str,bool,bool]:
-    msg = ""
-    known_guid = None
-    valid = True
-    exists = False
-    
-    elements_txt = extract_attribute(txt, [element_type])
-
-    if elements_txt is None:
-        msg += f"* {INFO}No Solution Blueprints found\n"
-    
-    else:
-        element_list = re.split(r'[,\n]+', elements_txt)
-        elements = ""
-        new_element_list = []
-        for element in element_list:
-            element_el = element.strip()
-            if element_el not in element_dictionary:
-                # Get the element using the generalized function
-
-                el = get_element_by_name(egeria_client, element_type, element_el)
-                if isinstance(el, str):
-                    msg += (f"* {WARNING}Blueprint `{element_el}` not found -> "
-                            f"Blueprints for this Solution Component won't be processed!\n")
-                    el_exist = False
-                    break
-    
-                # Extract properties using the element type name to construct property access
-                properties_key = f"{element_type}Properties"
-                el_qname = el[0][properties_key].get('qualifiedName', None)
-    
-                if el_qname not in element_dictionary:
-                    el_guid = el[0]['elementHeader']['guid']
-                    el_display_name = el[0][properties_key].get('displayName', None)
-                    element_dictionary[el_qname] = {
-                        'guid': el_guid,
-                        'displayName': el_display_name
-                        }
-            elements = f"{el_qname}, {elements}"
-            new_element_list.append(el_qname)
-        if el_exist:
-            elements += '\n'
-            element_list = new_element_list
-        else:
-            elements = None
+#
+# from typing import List, Optional
+#
+# import os
+# import re
+#
+# from rich import box, print
+# from rich.console import Console
+# from rich.markdown import Markdown
+#
+# from pyegeria import body_slimmer
+# from pyegeria._globals import NO_TERMS_FOUND, NO_GLOSSARIES_FOUND, NO_TERMS_FOUND, NO_ELEMENTS_FOUND, NO_PROJECTS_FOUND, NO_CATEGORIES_FOUND
+# from pyegeria.egeria_tech_client import EgeriaTech
+# from pyegeria.md_processing_utils import extract_attribute, get_element_by_name, process_element_identifiers
+# from pyegeria.project_manager_omvs import ProjectManager
+# from pyegeria.glossary_manager_omvs import GlossaryManager
+# ERROR = "ERROR-> "
+# INFO = "INFO- "
+# WARNING = "WARNING-> "
+# pre_command = "\n---\n==> Processing command:"
+#
+#
+#
+# def process_q_name_list(egeria_client: EgeriaTech, element_type:str, txt:str )-> tuple[str | None,list | None,str | None,bool,bool]:
+#     msg = ""
+#     known_guid = None
+#     valid = True
+#     exists = False
+#     elements = ""
+#     new_element_list = []
+#
+#     elements_txt = extract_attribute(txt, [element_type])
+#
+#     if elements_txt is None:
+#         msg += f"* {INFO}No {element_type}s found\n"
+#
+#     else:
+#         element_list = re.split(r'[,\n]+', elements_txt)
+#
+#         for element in element_list:
+#             element_el = element.strip()
+#
+#                 # Get the element using the generalized function
+#             known_q_name, known_guid, status_msg, el_valid, el_exists = get_element_by_name(
+#                 egeria_client, element_type,txt)
+#             msg += status_msg
+#             if exists and valid:
+#                 elements = f"{element_el}, {elements}" # list of the input names
+#                 new_element_list.append(known_q_name) # list of qualified names
+#             valid = valid and el_valid
+#             exists = exists and el_exists
+#
+#         if elements:
+#             elements += "\n"
+#             msg += f"* {INFO}Found {element_type}s: {elements}"
+#         else:
+#             msg += f"* {INFO}List contains one or more invalid elements.\n"
+#         return elements,new_element_list, msg, valid, exists

pyegeria/md_processing_utils.py

@@ -20,11 +20,13 @@ from rich.markdown import Markdown
 from pyegeria import body_slimmer
 from pyegeria._globals import NO_TERMS_FOUND, NO_GLOSSARIES_FOUND, NO_TERMS_FOUND, NO_ELEMENTS_FOUND, NO_PROJECTS_FOUND, NO_CATEGORIES_FOUND
 from pyegeria.egeria_tech_client import EgeriaTech
+# from pyegeria.md_processing_helpers import process_q_name_list
 from pyegeria.project_manager_omvs import ProjectManager
 from pyegeria.glossary_manager_omvs import GlossaryManager
+from pyegeria.shared_state import get_element_dictionary, update_element_dictionary
 
 from datetime import datetime
-EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "200"))
+EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "170"))
 console = Console(width=EGERIA_WIDTH)
 
 command_list = ["Provenance",
@@ -32,14 +34,15 @@ command_list = ["Provenance",
                 "Create Term", "Update Term",
                 "Create Personal Project", "Update Personal Project",
                 "Create Category", "Update Category",
-                "Create Solution Blueprint", "Update Solution Blueprint"]
+                "Create Solution Blueprint", "Update Solution Blueprint",
+                "Create Solution Component", "Update Solution Component",]
 
 ERROR = "ERROR-> "
 INFO = "INFO- "
 WARNING = "WARNING-> "
 pre_command = "\n---\n==> Processing command:"
 
-element_dictionary = {}
+
 
 def render_markdown(markdown_text: str) -> None:
     """Renders the given markdown text in the console."""
@@ -67,8 +70,9 @@ def add_term_to_categories(egeria_client: GlossaryManager, term_guid: str, categ
         for category in categories_list:
             cat_guid = None
             cat_el = category.strip()
-            if cat_el in element_dictionary:
-                cat= element_dictionary.get(cat_el, None)
+            element_dict = get_element_dictionary()
+            if cat_el in element_dict:
+                cat = element_dict.get(cat_el, None)
                 cat_guid = cat.get('guid', None) if cat else None
             if cat_guid is None:
                 cat_guid = egeria_client.__get_guid__(qualified_name=cat_el)
@@ -160,7 +164,8 @@ def process_provenance_command(file_path: str, txt: [str]) -> str:
     existing_prov = existing_prov if existing_prov else " "
     return f"\n# Provenance:\n{existing_prov}\n{output}\n"
 
-def process_element_identifiers(egeria_client: EgeriaTech, element_type:str, txt: str) -> tuple[str, str, str, bool, bool]:
+def process_element_identifiers(egeria_client: EgeriaTech, element_type:str, txt: str, action: str, version: str=None) \
+        -> tuple[str, str, str, bool, bool]:
     """
     Processes element identifiers by extracting display name and qualified name from the input text,
     checking if the element exists in Egeria, and validating the information.
@@ -172,6 +177,10 @@ def process_element_identifiers(egeria_client: EgeriaTech, element_type:str, txt
         type of element to process (e.g., 'blueprint', 'category', 'term')
     txt: str
         A string representing the input text to be processed for extracting element identifiers.
+    action: str
+        The action command to be executed (e.g., 'Create', 'Update', 'Display', ...)
+    version: str, optional = None
+        An optional version identifier used if we need to construct the qualified name
 
     Returns: tuple[str, str, str, bool, bool]
         A tuple containing:
@@ -181,44 +190,42 @@ def process_element_identifiers(egeria_client: EgeriaTech, element_type:str, txt
         - Valid: Boolean indicating if the element information is valid
         - Exists: Boolean indicating if the element exists in Egeria
     """
-
     msg = ""
-    known_guid = None
+    guid = None
     valid = True
     exists = False
+    unique: bool | None = None
     display_name = extract_attribute(txt, ["Display Name"])
-    if display_name is None:
-        msg = f"* {ERROR}Display name is missing\n"
-        valid = False
-        return "","", msg, valid, exists
+
     qualified_name = extract_attribute(txt, ["Qualified Name"])
     if qualified_name:
-        element_details = get_element_by_name(egeria_client,element_type,qualified_name)
+        q_name, guid, msg, unique, exists  = get_element_by_name(egeria_client,element_type,qualified_name)
+        # Qualified name could be different if it is being updated
     else:
-        element_details = get_element_by_name(egeria_client,element_type,display_name)
+         q_name, guid, msg, unique, exists = get_element_by_name(egeria_client,element_type,display_name)
+    if unique is False:
+        msg += f"{ERROR} Multiple elements named  {display_name} found\n"
+        valid = False
+    if action == "Update" and not exists:
+        msg += f"* {ERROR}Element {display_name} does not exist\n"
+        valid = False
+    elif action == "Update" and exists:
+        msg += f"* {INFO}Element {display_name} exists\n"
+    elif action == "Create" and exists:
+        msg += f"* {ERROR}Element {display_name} already exists\n"
+        valid = False
+    elif action == "Create" and not exists:
+        msg += f"* {INFO}Element {display_name} does not exist and can be created\n"
+        if q_name is None:
+            q_name = egeria_client.__create_qualified_name__(element_type, display_name,
+                                                             version_identifier=version)
+            update_element_dictionary(q_name, {'display_name': display_name})
 
-    if type(element_details) is str:
-        exists = False
-    else:
-        exists = True
+    return q_name, guid, msg, valid, exists
 
-    if len(element_details) > 1 and exists:
-        msg += (f"* {ERROR}More than one element with name {display_name} found, please specify a "
-                f"**Qualified Name**\n")
-        valid = False
-    elif len(element_details) == 1:
-        known_guid = element_details[0]['elementHeader'].get('guid', None)
-        known_q_name = element_details[0]['glossaryTermProperties'].get('qualifiedName', None)
-        if qualified_name != known_q_name:
-            msg += (f"* {ERROR}Element {display_name} qualifiedName mismatch between {qualified_name} and {known_q_name}\n")
-            valid = False
-        else:
-            msg += f"\n--> * Element {display_name} exists and can be updated\n"
-            # msg += term_display
-            # element_dictionary[known_q_name] = {'display_name': display_name, 'guid': known_guid}
-    return qualified_name, known_guid, msg, valid, exists
 
-def get_element_by_name(egeria_client, element_type: str, element_name: str):
+def get_element_by_name(egeria_client, element_type: str, element_name: str)\
+        ->tuple[str | None, str | None, str, bool | None, bool | None]:
     """
     Generalized function to retrieve an element by name based on its type.
 
@@ -231,28 +238,119 @@ def get_element_by_name(egeria_client, element_type: str, element_name: str):
         The name of the element to retrieve.
 
     Returns:
-        The element if found, or a string indicating no elements were found.
+        tuple of qualified_name, guid, msg, uniqye, exists
     """
+    unique = None
+    element_dict = get_element_dictionary()
+    if element_name in element_dict: # use information from element_dictionary
+        guid = element_dict[element_name].get('guid',None)
+        unique = True
+        exists = False
+        if guid is not None: # Found complete entry in element_dictionary
+            return element_name, guid, 'Found qualified name', unique, exists
+        else: # Missing guid from element_dictionary
+            guid = egeria_client.get_element_guid_by_unique_name(element_name)
+            if guid == NO_ELEMENTS_FOUND:
+                exists = False
+                msg = f"{INFO}No {element_type} guid found with name {element_name}\n"
+                return element_name, None, msg, unique, exists
+            else:
+                exists = True
+                update_element_dictionary(element_name, {'guid': guid})
+                return element_name, guid, 'Found qualified name', unique, exists
+
+    # Haven't seen this element before
+    property_names = ['qualifiedName', 'name', 'displayName']
+    open_metadata_type_name = None
+    details =  egeria_client.get_elements_by_property_value(
+        element_name, property_names, open_metadata_type_name
+        )
+    if isinstance(details, str):
+        msg = f"{INFO}{element_type} `{element_name}` not found\n"
+        exists = False
+        return element_name, None, msg, unique, exists
+    if len(details) > 1:
+        msg = (f"{ERROR}More than one element with name {element_name} found, please specify a "
+                f"**Qualified Name**\n")
+        unique= False
+        exists = None
+        return element_name, None, msg, unique, exists
+
+    el_qname = details[0]["properties"].get('qualifiedName', None)
+    el_guid = details[0]['elementHeader']['guid']
+    el_display_name = details[0]["properties"].get('displayName', None)
+    update_element_dictionary(el_qname, {
+        'guid': el_guid,
+        'displayName': el_display_name
+        })
+    msg = f"{INFO}Found {element_type} `{element_name}`\n"
+    exists = True
+    unique = True
+    return el_qname, el_guid, msg, unique, exists
+
     # Convert element_type to plural form for method name construction
-    if element_type.endswith('y'):
-        plural_type = f"{element_type[:-1]}ies"
-    elif element_type.endswith('s'):
-        plural_type = f"{element_type}es"
-    else:
-        plural_type = f"{element_type}s"
+    # if element_type.endswith('y'):
+    #     plural_type = f"{element_type[:-1]}ies"
+    # elif element_type.endswith('s'):
+    #     plural_type = f"{element_type}es"
+    # else:
+    #     plural_type = f"{element_type}s"
+    #
+    # # Construct method name
+    # method_name = f"get_{plural_type}_by_name"
+    #
+    # # Check if the method exists on the client
+    # if hasattr(egeria_client, method_name):
+    #     # Call the method
+    #     method = getattr(egeria_client, method_name)
+    #     result = method(element_name)
+    #     return result
+    # else:
+    #     # Method doesn't exist
+    #     return f"Method {method_name} not found on client"
+
+
+
+def process_q_name_list(egeria_client: EgeriaTech, element_type: str, txt: str) -> tuple[
+    str | None, list | None, str | None, bool, bool]:
+    msg = ""
+    known_guid = None
+    valid = True
+    exists = False
+    elements = ""
+    new_element_list = []
+
+    elements_txt = extract_attribute(txt, [element_type])
 
-    # Construct method name
-    method_name = f"get_{plural_type}_by_name"
+    if elements_txt is None:
+        msg += f"* {INFO}No {element_type}s found\n"
 
-    # Check if the method exists on the client
-    if hasattr(egeria_client, method_name):
-        # Call the method
-        method = getattr(egeria_client, method_name)
-        result = method(element_name)
-        return result
     else:
-        # Method doesn't exist
-        return f"Method {method_name} not found on client"
+        element_list = re.split(r'[,\n]+', elements_txt)
+
+        for element in element_list:
+            element_el = element.strip()
+
+            # Get the element using the generalized function
+            known_q_name, known_guid, status_msg, el_valid, el_exists = get_element_by_name(
+                egeria_client, element_type, element_el)
+            msg += status_msg
+            if el_exists and el_valid:
+                elements = f"{element_el}, {elements}"  # list of the input names
+                new_element_list.append(known_q_name)  # list of qualified names
+            elif not el_exists:
+                msg += f"* {INFO}No {element_type} `{element_el}` found\n"
+                valid = False
+            valid = valid if el_valid is None else valid and el_valid
+            exists = exists and el_exists
+
+        if elements:
+            elements += "\n"
+            msg += f"* {INFO}Found {element_type}s: {elements}"
+        else:
+            msg += f"* {INFO}List contains one or more invalid elements.\n"
+        return elements, new_element_list, msg, valid, exists
+
 
 
 
@@ -274,16 +372,23 @@ def process_blueprint_upsert_command(egeria_client: EgeriaTech, element_dictiona
     Returns: str
         A string summarizing the outcome of the processing.
     """
-
     object_type, object_action = extract_command_plus(txt)
     element_display = ""
+    valid = True
+    msg =""
+
     display_name = extract_attribute(txt, ['Display Name','Blueprint Name'])
     description = extract_attribute(txt, ['Description'])
     version = extract_attribute(txt, ['Version', "Version Identifier", "Published Version"])
 
-    print(Markdown(f"{pre_command} `{object_type}{object_action}` for Blueprint: `\'{display_name}\'` with directive: `{directive}`"))
-
-    known_q_name, known_guid, msg, valid, exists = process_element_identifiers(egeria_client, object_type,txt)
+    print(Markdown(f"{pre_command} {object_action} `{object_type}` for Blueprint: `\'{display_name}\'` with directive: `{directive}`\n"))
+    if display_name is None:
+        msg += f"* {ERROR}Display name is missing\n"
+        valid = False
+        q_name, known_guid, exists = None
+    else:
+        q_name, known_guid, status_msg, valid, exists = process_element_identifiers(egeria_client, object_type,txt, object_action)
+        msg+= status_msg
 
     if description is None:
         msg += f"* {INFO}Description is missing\n"
@@ -298,32 +403,33 @@ def process_blueprint_upsert_command(egeria_client: EgeriaTech, element_dictiona
 
     element_display = (f"\n* Command: {object_action} {object_type}\n\t* Blueprint: {display_name}\n\t"
                        f"* Description: {description}\n\t"
-                       f"* Version: {version}\n\t* Qualified Name:{known_q_name}\n\t* GUID: {known_guid} "
+                       f"* Version: {version}\n\t* Qualified Name:{q_name}\n\t* GUID: {known_guid} "
                        f"\n\t* Update Description: {update_description}\n")
 
-    if object_action == "Update":  # check to see if provided information exists and is consistent with existing info
-        if not exists:
-            msg += f"* {ERROR}Element {display_name} does not exist\n"
-            valid = False
-            element_dictionary[known_q_name] = {'display_name': display_name, 'guid': known_guid}
-
-    elif object_action == 'Create':  # if the command is create, check that it doesn't already exist
-        if exists:
-            msg += f"\n{WARNING}Element \'{display_name}\' already exists.\n"
-        elif not valid:
-            msg += f"\n-->Validation checks failed in creating element \'{display_name}\' with: {element_display}\n"
-        else: # valid to create - update element_dictionary
-            msg += f"\n-->It is valid to create element \'{display_name}\' with: {element_display}\n"
-            if known_q_name is None:
-                known_q_name = egeria_client.__create_qualified_name__(object_type, display_name)
-            element_dictionary[known_q_name] = {'display_name': display_name}
-
+    # if object_action == "Update":  # check to see if provided information exists and is consistent with existing info
+    #     if not exists:
+    #         msg += f"* {ERROR}Element {display_name} does not exist\n"
+    #         valid = False
+
+    # elif object_action == 'Create':  # if the command is create, check that it doesn't already exist
+    #     if exists:
+    #         msg += f"\n{WARNING}Element \'{display_name}\' already exists.\n"
+    #     elif not valid:
+    #         msg += f"\n-->Validation checks failed in creating element \'{display_name}\' with: {element_display}\n"
+    #     else: # valid to create - update element_dictionary
+    #         msg += f"\n-->It is valid to create element \'{display_name}\' with: {element_display}\n"
+    #         if known_q_name is None:
+    #             known_q_name = egeria_client.__create_qualified_name__(object_type, display_name)
+    #             element_dictionary[known_q_name] = {'display_name': display_name}
+    if valid:
+        msg += f"\n-->It is valid to create element \'{display_name}\' with: {element_display}\n"
 
     if directive == "display":
         print(Markdown(element_display))
         return None
     elif directive == "validate":
         print(Markdown(msg))
+        print(Markdown(element_display))
         return valid
 
     elif directive == "process":
@@ -350,16 +456,16 @@ def process_blueprint_upsert_command(egeria_client: EgeriaTech, element_dictiona
                 if exists:
                     print(f"\n{WARNING}Blueprint {display_name} exists and result document updated")
                     return update_a_command(txt, f"{object_type}{object_action}",
-                    object_type, known_q_name, known_guid)
+                    object_type, q_name, known_guid)
                 else:
                    # create the blueprint
                     #term_guid = egeria_client.create_controlled_glossary_term(glossary_guid, term_body)
                     # if term_guid == NO_ELEMENTS_FOUND:
                     #     print(f"{ERROR}Term {term_name} not created")
                     #     return None
-
-                    print(f"\n-->Created Blueprint {display_name} with GUID {known_guid}")
-                    element_dictionary[known_q_name] = {'guid': known_guid, 'display_name': display_name}
+                    new_guid= f"guid:{get_current_datetime_string()}"
+                    print(f"\n-->Created Blueprint {display_name} with GUID {new_guid}")
+                    update_element_dictionary(q_name, {'guid': new_guid, 'display_name': display_name})
                     return 'Would return get blueprint by guid results as md' #egeria_client.get_terms_by_guid(term_guid, 'MD')
 
         except Exception as e:
@@ -387,10 +493,12 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, element
     Returns: str
         A string summarizing the outcome of the processing.
     """
-
     object_type, object_action = extract_command_plus(txt)
     element_display = ""
     bp_exist = True
+    bp_qname_list = []
+    parent_qname_list = []
+
     display_name = extract_attribute(txt, ['Display Name', 'Solution Component Name'])
     description = extract_attribute(txt, ['Description'])
     version = extract_attribute(txt, ['Version', "Version Identifier", "Published Version"])
@@ -400,9 +508,9 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, element
     parent_components = extract_attribute(txt, ['Parent Components'])
 
     print(Markdown(
-        f"{pre_command} `{object_type}{object_action}` for Solution Component: `\'{display_name}\'` with directive: `{directive}`"))
+        f"{pre_command}  {object_action} `{object_type}` for Solution Component: `\'{display_name}\'` with directive: `{directive}`\n"))
 
-    known_q_name, known_guid, msg, valid, exists = process_element_identifiers(egeria_client, object_type,txt)
+    known_q_name, known_guid, msg, valid, exists = process_element_identifiers(egeria_client, object_type,txt, object_action)
 
     if description is None:
         msg += f"* {INFO}Description is missing\n"
@@ -424,54 +532,31 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, element
     if solution_blueprints is None:
         msg += f"* {INFO}No Solution Blueprints found\n"
 
-    else:
-        blueprint_list = re.split(r'[,\n]+', solution_blueprints)
-        blueprints = ""
-        new_blueprint_list = []
-        for blueprint in blueprint_list:
-            blueprint_el = blueprint.strip()
-            if blueprint_el not in element_dictionary:
-                # Get the blueprint using the generalized function
-                element_type = 'blueprint'
-                bp = get_element_by_name(egeria_client, element_type, blueprint_el)
-                if isinstance(bp, str):
-                    msg += (f"* {WARNING}Blueprint `{blueprint_el}` not found -> "
-                            f"Blueprints for this Solution Component won't be processed!\n")
-                    bp_exist = False
-                    break
-
-                # Extract properties using the element type name to construct property access
-                properties_key = f"{element_type}Properties"
-                bp_qname = bp[0][properties_key].get('qualifiedName', None)
-
-                if bp_qname not in element_dictionary:
-                    bp_guid = bp[0]['elementHeader']['guid']
-                    bp_display_name = bp[0][properties_key].get('displayName', None)
-                    element_dictionary[bp_qname] = {
-                        'guid': bp_guid,
-                        'displayName': bp_display_name
-                        }
-            blueprints = f"{bp_qname}, {blueprints}"
-            new_blueprint_list.append(bp_qname)
-        if bp_exist:
-            blueprints += '\n'
-            blueprint_list = new_blueprint_list
-        else:
-            blueprints = None
+    else: # Find information about blueprints that include this component
+        solution_blueprints, bp_qname_list, msg, valid, exists = process_q_name_list(egeria_client,
+                                            'Solution Blueprints', txt)
 
     if parent_components is None:
         msg += f"* {INFO}Parent Components are missing\n"
+    else:
+        parent_components, parent_qname_list, msg, valid, exists = process_q_name_list(egeria_client,
+                                            'Solution Component', parent_components)
 
-    element_display = (f"\n* Command: {object_action} {object_type}\n\t* Blueprint: {display_name}\n\t"
+    element_display = (f"\n* Command: {object_action} {object_type}\n\t* Display Name: {display_name}\n\t"
                        f"* Description: {description}\n\t"
-                       f"* Version: {version}\n\t* Qualified Name:{known_q_name}\n\t* GUID: {known_guid} "
+                       f"* Version Identifier: {version}\n\t"
+                       f"* Solution Component Type {solution_component_type}\n\t"
+                       f"* Planned Deployment Implementation Type {planned_deployed_implementation_type}\n\t"
+                       f"* Solution_Blueprints: {solution_blueprints}\n\t"
+                       f"* Parent Components: {parent_components}\n\t"
+                       f"* Qualified Name:{known_q_name}\n\t* GUID: {known_guid} "
                        f"\n\t* Update Description: {update_description}\n")
 
     if object_action == "Update":  # check to see if provided information exists and is consistent with existing info
         if not exists:
             msg += f"* {ERROR}Element {display_name} does not exist\n"
             valid = False
-            element_dictionary[known_q_name] = {'display_name': display_name, 'guid': known_guid}
+            # element_dictionary[known_q_name] = {'display_name': display_name, 'guid': known_guid}
 
     elif object_action == 'Create':  # if the command is create, check that it doesn't already exist
         if exists:
@@ -481,14 +566,16 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, element
         else:  # valid to create - update element_dictionary
             msg += f"\n-->It is valid to create element \'{display_name}\' with: {element_display}\n"
             if known_q_name is None:
-                known_q_name = egeria_client.__create_qualified_name__(object_type, display_name)
-            element_dictionary[known_q_name] = {'display_name': display_name}
+                known_q_name = egeria_client.__create_qualified_name__(object_type, display_name,
+                                                                       version_identifier=version)
+            update_element_dictionary(known_q_name, {'display_name': display_name})
 
     if directive == "display":
         print(Markdown(element_display))
         return None
     elif directive == "validate":
         print(Markdown(msg))
+        print(Markdown(element_display))
         return valid
 
     elif directive == "process":
@@ -499,14 +586,14 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, element
 
             if object_action == "Update" and directive == "process":
                 if not exists:
-                    print(f"\n-->Blueprint {display_name} does not exist")
+                    print(f"\n-->Solution Component {display_name} does not exist")
                     return None
 
-                # call update blueprint here
+                # call update solution component here
 
-                print(f"\n-->Updated Blueprint {display_name} with GUID {known_guid}")
-                # update with get blueprint by guid
-                return 'Would return get blueprint by guid and return md'  # egeria_client.get_terms_by_guid(known_guid, 'md')
+                print(f"\n-->Updated Solution Component {display_name} with GUID {known_guid}")
+                # update with get solution component by guid
+                return 'Would return get Solution Component by guid and return md'  # egeria_client.get_terms_by_guid(known_guid, 'md')
 
             elif object_action == "Update" and directive == "validate":
                 return 'Would call get_blueprint_by_guid and return md'  # egeria_client.get_terms_by_guid(known_guid, 'md')
@@ -523,9 +610,9 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, element
                     #     print(f"{ERROR}Term {term_name} not created")
                     #     return None
 
-                    print(f"\n-->Created Blueprint {display_name} with GUID {known_guid}")
-                    element_dictionary[known_q_name] = {'guid': known_guid, 'display_name': display_name}
-                    return 'Would return get blueprint by guid results as md'  # egeria_client.get_terms_by_guid(term_guid, 'MD')
+                    print(f"\n-->Created Solution Component {display_name} with GUID {known_guid}")
+                    update_element_dictionary(known_q_name, {'guid': known_guid, 'display_name': display_name})
+                    return 'Would return get solution component by guid results as md'  # egeria_client.get_terms_by_guid(term_guid, 'MD')
 
         except Exception as e:
             print(f"{ERROR}Error creating term {display_name}: {e}")
@@ -568,7 +655,7 @@ def process_glossary_upsert_command(egeria_client: GlossaryManager, element_dict
         valid = True
         msg = ""
 
-        known_q_name, known_guid, msg, valid, glossary_exists = process_element_identifiers(egeria_client, object_type,txt)
+        known_q_name, known_guid, msg, valid, glossary_exists = process_element_identifiers(egeria_client, object_type,txt, object_action)
 
         if glossary_name is None:
             msg = f"* {ERROR}Glossary name is missing\n"
@@ -595,7 +682,7 @@ def process_glossary_upsert_command(egeria_client: GlossaryManager, element_dict
             if valid:
                 msg += glossary_display
                 msg += f"* -->Glossary `{glossary_name}` exists and can be updated\n"
-                element_dictionary[known_q_name] = {'display_name': glossary_name, 'guid': known_guid}
+                update_element_dictionary(known_q_name, {'display_name': glossary_name, 'guid': known_guid})
             else:
                 msg += f"* --> validation failed\n"
 
@@ -610,7 +697,7 @@ def process_glossary_upsert_command(egeria_client: GlossaryManager, element_dict
                 msg += f"-->It is valid to create Glossary \'{glossary_name}\' with:\n"
                 msg += glossary_display
                 expected_q_name = egeria_client.__create_qualified_name__('Glossary', glossary_name)
-                element_dictionary[expected_q_name] = {'display_name': glossary_name}
+                update_element_dictionary(expected_q_name, {'display_name': glossary_name})
 
             print(Markdown(msg))
             return valid, glossary_exists, known_guid, known_q_name
@@ -642,9 +729,9 @@ def process_glossary_upsert_command(egeria_client: GlossaryManager, element_dict
                 }
             egeria_client.update_glossary(known_guid, body)
             print(f"\n-->Updated Glossary {glossary_name} with GUID {known_guid}")
-            element_dictionary[known_q_name] = {
+            update_element_dictionary(known_q_name, {
                 'guid': known_guid, 'display_name': glossary_name
-                }
+                })
             # return update_a_command(txt, command, object_type, known_q_name, known_guid)
             return egeria_client.get_glossary_by_guid(known_guid, output_format='MD')
         elif object_action == "Create":
@@ -660,9 +747,9 @@ def process_glossary_upsert_command(egeria_client: GlossaryManager, element_dict
                     print(f"{ERROR}Just created with GUID {glossary_guid} but Glossary not found\n")
                     return None
                 qualified_name = glossary['glossaryProperties']["qualifiedName"]
-                element_dictionary[qualified_name] = {
+                update_element_dictionary(qualified_name, {
                     'guid': glossary_guid, 'display_name': glossary_name
-                    }
+                    })
                 # return update_a_command(txt, command, object_type, qualified_name, glossary_guid)
                 return egeria_client.get_glossary_by_guid(glossary_guid, output_format = 'MD')
 
@@ -715,9 +802,10 @@ def process_categories_upsert_command(egeria_client: GlossaryManager, element_di
             msg += f"* {ERROR}Owning Glossary Qualified Name is missing\n"
             valid = False
 
-        elif owning_glossary_qn in element_dictionary:  # Check to see if we already know about this glossary
-            glossary_name = element_dictionary[owning_glossary_qn].get('display_name', None)
-            glossary_guid = element_dictionary[owning_glossary_qn].get('guid', None)
+        elif owning_glossary_qn in get_element_dictionary():  # Check to see if we already know about this glossary
+            element_dict = get_element_dictionary()
+            glossary_name = element_dict[owning_glossary_qn].get('display_name', None)
+            glossary_guid = element_dict[owning_glossary_qn].get('guid', None)
 
         else:
             # need to ask Egeria if it knows the Glossary Name
@@ -734,9 +822,9 @@ def process_categories_upsert_command(egeria_client: GlossaryManager, element_di
                     msg += f"* {ERROR}Glossary `{owning_glossary_qn}` is known by qualifiedName `{glossary_qn}`\n\n"
                     valid = False
                 else:
-                    element_dictionary[owning_glossary_qn] = {
+                    update_element_dictionary(owning_glossary_qn, {
                         'guid': glossary_guid, 'display_name': glossary_name
-                        }
+                        })
 
         if category_name is None:
             msg = f"* {ERROR}Category name is missing\n"
@@ -766,7 +854,7 @@ def process_categories_upsert_command(egeria_client: GlossaryManager, element_di
             if valid:
                 msg += category_display
                 msg += f"* -->category `{category_name}` exists and can be updated\n"
-                element_dictionary[known_q_name] = {'display_name': glossary_name, 'guid': known_category_guid}
+                update_element_dictionary(known_q_name, {'display_name': glossary_name, 'guid': known_category_guid})
             else:
                 msg += f"* --> validation failed\n"
 
@@ -781,7 +869,7 @@ def process_categories_upsert_command(egeria_client: GlossaryManager, element_di
                 msg += f"-->It is valid to create category `{category_name}` with:\n"
                 msg += category_display
                 expected_q_name = egeria_client.__create_qualified_name__('Category', category_name)
-                element_dictionary[expected_q_name] = {'display_name': category_name}
+                update_element_dictionary(expected_q_name, {'display_name': category_name})
 
             print(Markdown(msg))
             return valid, category_exists, known_category_guid, known_q_name, glossary_guid
@@ -811,9 +899,9 @@ def process_categories_upsert_command(egeria_client: GlossaryManager, element_di
             egeria_client.update_category(glossary_guid, category_name, description, known_q_name, None,
                                           update_description)
             print(f"\n-->Updated category `{category_name}`with GUID {known_guid}")
-            element_dictionary[known_q_name] = {
+            update_element_dictionary(known_q_name, {
                 'guid': known_guid, 'display_name': category_name
-                }
+                })
             # return update_a_command(txt, command, object_type, known_q_name, known_guid)
             return egeria_client.get_categories_by_guid(known_guid, output_format='FORM')
 
@@ -831,9 +919,9 @@ def process_categories_upsert_command(egeria_client: GlossaryManager, element_di
                     print(f"{ERROR}Just created with GUID {category_guid} but category not found\n")
                     return None
                 qualified_name = category['glossaryCategoryProperties']["qualifiedName"]
-                element_dictionary[qualified_name] = {
+                update_element_dictionary(qualified_name, {
                     'guid': category_guid, 'display_name': category_name
-                    }
+                    })
                 # return update_a_command(txt, command, object_type, qualified_name, category_guid)
                 return egeria_client.get_categories_by_guid(category_guid, output_format='MD')
 
@@ -905,7 +993,8 @@ def process_term_upsert_command(egeria_client: GlossaryManager, element_dictiona
             valid = False
         else:
             print(f"* {INFO}Glossary qualified name is `{glossary_qn}`")
-            if glossary_qn not in element_dictionary:
+            element_dict = get_element_dictionary()
+            if glossary_qn not in element_dict:
                 glossary = egeria_client.get_glossaries_by_name(glossary_qn) #assuming q_name?
                 if isinstance(glossary,str):
                     msg += f"* {ERROR}Glossary `{glossary_qn}` is unknown\n "
@@ -919,10 +1008,10 @@ def process_term_upsert_command(egeria_client: GlossaryManager, element_dictiona
                         msg += f"* {ERROR}Glossary `{glossary_qn}` has no qualifiedName\n "
                         valid = False
                     else:
-                        element_dictionary[glossary_qn] = {
+                        update_element_dictionary(glossary_qn, {
                         'guid': glossary[0]['elementHeader'].get('guid', None),
                         'display_name': glossary[0]['glossaryProperties'].get('displayName', None)
-                        }
+                        })
 
 
         if categories is None:
@@ -933,7 +1022,8 @@ def process_term_upsert_command(egeria_client: GlossaryManager, element_dictiona
             new_cat_list = []
             for category in categories_list:
                 category_el = category.strip()
-                if category_el not in element_dictionary:
+                element_dict = get_element_dictionary()
+                if category_el not in element_dict:
                     cat = egeria_client.get_categories_by_name(category_el) # assuming qualified name?
                     if isinstance(cat,str):
                         msg += (f"* {WARNING}Category `{category_el}` not found -> "
@@ -942,13 +1032,13 @@ def process_term_upsert_command(egeria_client: GlossaryManager, element_dictiona
                         break
                     cat_qname = cat[0]['glossaryCategoryProperties'].get('qualifiedName', None)
                     category = cat_qname # use the qualified name if found
-                    if cat_qname not in element_dictionary:
+                    if cat_qname not in element_dict:
                         cat_guid = cat[0]['elementHeader']['guid']
                         cat_display_name = cat[0]['glossaryCategoryProperties'].get('displayName', None)
-                        element_dictionary[cat_qname] = {
+                        update_element_dictionary(cat_qname, {
                             'guid' : cat_guid,
                             'displayName': cat_display_name
-                            }
+                            })
                 categories = f"{category}, {categories}"
                 new_cat_list.append(category)
             if cats_exist:
@@ -993,7 +1083,7 @@ def process_term_upsert_command(egeria_client: GlossaryManager, element_dictiona
             else:
                 msg += f"\n--> * Term {term_name} exists and can be updated\n"
                 msg += term_display
-                element_dictionary[known_q_name] = {'display_name': term_name, 'guid': known_term_guid}
+                update_element_dictionary(known_q_name, {'display_name': term_name, 'guid': known_term_guid})
 
             print(Markdown(msg))
             return valid, term_exists, known_term_guid, known_q_name
@@ -1006,10 +1096,11 @@ def process_term_upsert_command(egeria_client: GlossaryManager, element_dictiona
             else:
                 msg += f"\n-->It is valid to create Term \'{term_name}\' with: {term_display}\n"
                 if q_name is None:
-                    expected_q_name = egeria_client.__create_qualified_name__('Term', term_name)
-                    element_dictionary[expected_q_name] = {'display_name': term_name}
+                    expected_q_name = egeria_client.__create_qualified_name__('Term',
+                                                                              term_name, version_identifier=version)
+                    update_element_dictionary(expected_q_name, {'display_name': term_name})
                 else:
-                    element_dictionary[q_name] = {'display_name': term_name}
+                    update_element_dictionary(q_name, {'display_name': term_name})
             print(Markdown(msg))
             return valid, term_exists, known_term_guid, known_q_name
 
@@ -1086,13 +1177,14 @@ def process_term_upsert_command(egeria_client: GlossaryManager, element_dictiona
             elif object_action == "Create":
                 guid = None
                 if q_name is None:
-                    q_name = egeria_client.__create_qualified_name__("Term",term_name)
+                    q_name = egeria_client.__create_qualified_name__("Term",term_name,
+                                                                     version_identifier=version)
                 if exists:
                     print(f"\n{WARNING}Term {term_name} exists and result document updated")
                     return update_a_command(txt, command, object_type, q_name, known_guid)
                 else:
                     ## get the guid for the glossary from the name - first look locally
-                    glossary = element_dictionary.get(glossary_qn, None)
+                    glossary = get_element_dictionary().get(glossary_qn, None)
 
                     if glossary is not None:
                         glossary_guid = glossary.get('guid', None)
@@ -1131,7 +1223,7 @@ def process_term_upsert_command(egeria_client: GlossaryManager, element_dictiona
                         egeria_client, term_guid, cats_exist, categories_list,
                         element_dictionary)
                     print(f"\n-->Created Term {term_name} with GUID {term_guid}")
-                    element_dictionary[q_name] = {'guid': term_guid, 'display_name': term_name}
+                    update_element_dictionary(q_name, {'guid': term_guid, 'display_name': term_name})
                     return egeria_client.get_terms_by_guid(term_guid, 'MD')
                     # return update_a_command(txt, command, object_type, q_name, term_guid)
         except Exception as e:
@@ -1279,11 +1371,11 @@ def process_per_proj_upsert_command(egeria_client: ProjectManager, element_dicti
                 guid = egeria_client.create_project(None, None, None, False, project_name, description,
                                                     "PersonalProject", project_identifier, True, project_status,
                                                     project_phase, project_health, start_date, planned_end_date)
-                project_g = egeria_client.get_project(guid)
+                project_g = egeria_client.get_project_by_guid(guid)
                 if project_g == NO_GLOSSARIES_FOUND:
                     print(f"Just created with GUID {guid} but Project not found")
                     return None
 
                 q_name = project_g['projectProperties']["qualifiedName"]
-                element_dictionary[q_name] = {'guid': guid, 'display_name': project_name}
+                update_element_dictionary(q_name, {'guid': guid, 'display_name': project_name})
                 return update_a_command(txt, command, object_type, q_name, guid)

pyegeria/md_processing_utils_orig.py

@@ -1093,7 +1093,7 @@ def process_per_proj_upsert_command(egeria_client: ProjectManager, element_dicti
                 guid = egeria_client.create_project(None, None, None, False, project_name, description,
                                                     "PersonalProject", project_identifier, True, project_status,
                                                     project_phase, project_health, start_date, planned_end_date)
-                project_g = egeria_client.get_project(guid)
+                project_g = egeria_client.get_project_by_guid(guid)
                 if project_g == NO_GLOSSARIES_FOUND:
                     print(f"Just created with GUID {guid} but Project not found")
                     return None

pyegeria/project_manager_omvs.py

@@ -635,7 +635,7 @@ class ProjectManager(Client):
 
         return resp
 
-    async def _async_get_project(
+    async def _async_get_project_by_guid(
         self,
         project_guid: str,
         effective_time: str = None,
@@ -677,7 +677,7 @@ class ProjectManager(Client):
         resp = await self._async_make_request("GET", url, body)
         return resp.json()
 
-    def get_project(self, project_guid: str, effective_time: str = None) -> dict | str:
+    def get_project_by_guid(self, project_guid: str, effective_time: str = None) -> dict | str:
         """Return the properties of a specific project.
 
         Parameters
@@ -707,11 +707,87 @@ class ProjectManager(Client):
         """
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
-            self._async_get_project(project_guid, effective_time)
+            self._async_get_project_by_guid(project_guid, effective_time)
         )
 
         return resp
 
+    async def _async_get_project_graph(
+        self,
+        project_guid: str,
+        effective_time: str = None,
+    ) -> dict | str:
+        """Return the mermaid graph of a specific project. Async version.
+
+        Parameters
+        ----------
+        project_guid: str,
+            unique identifier of the project.
+        effective_time: str, [default=None], optional
+             Effective time of the query. If not specified will default to any time. Time in ISO8601 format is assumed.
+
+
+        Returns
+        -------
+         str
+
+            A mermaid markdown string representing the graph of the project.
+        Raises
+        ------
+
+        InvalidParameterException
+          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+        PropertyServerException
+          Raised by the server when an issue arises in processing a valid request
+        NotAuthorizedException
+          The principle specified by the user_id does not have authorization for the requested action
+
+        """
+
+        validate_guid(project_guid)
+        body = {
+            "effective_time": effective_time,
+        }
+        url = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects/{project_guid}/graph"
+
+        resp = await self._async_make_request("GET", url, body)
+        return resp.json().get('element',NO_ELEMENTS_FOUND)
+
+    def get_project_graph(self, project_guid: str, effective_time: str = None) -> dict | str:
+        """Return the mermaid graph of a specific project.
+
+        Parameters
+        ----------
+        project_guid: str,
+            unique identifier of the project.
+        effective_time: str, [default=None], optional
+             Effective time of the query. If not specified will default to any time. Time in ISO8601 format is assumed.
+
+
+        Returns
+        -------
+         str
+
+            A mermaid markdown string representing the graph of the project.
+        Raises
+        ------
+
+        InvalidParameterException
+          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+        PropertyServerException
+          Raised by the server when an issue arises in processing a valid request
+        NotAuthorizedException
+          The principle specified by the user_id does not have authorization for the requested action
+
+        """
+        loop = asyncio.get_event_loop()
+        resp = loop.run_until_complete(
+            self._async_get_project_graph(project_guid, effective_time)
+        )
+
+        return resp
+
+
     #
     #   Create project methods
     #

pyegeria/shared_state.py

@@ -0,0 +1,35 @@
+"""
+This module provides shared state for the pyegeria package.
+It contains variables that need to be accessed and modified by multiple modules.
+"""
+
+# Dictionary to store element information to avoid redundant API calls
+element_dictionary = {}
+
+def get_element_dictionary():
+    """
+    Get the shared element dictionary.
+    
+    Returns:
+        dict: The shared element dictionary
+    """
+    global element_dictionary
+    return element_dictionary
+
+def update_element_dictionary(key, value):
+    """
+    Update the shared element dictionary with a new key-value pair.
+    
+    Args:
+        key (str): The key to update
+        value (dict): The value to associate with the key
+    """
+    global element_dictionary
+    element_dictionary[key] = value
+
+def clear_element_dictionary():
+    """
+    Clear the shared element dictionary.
+    """
+    global element_dictionary
+    element_dictionary.clear()

{pyegeria-5.3.7.7.dist-info → pyegeria-5.3.7.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyegeria
-Version: 5.3.7.7
+Version: 5.3.7.8
 Summary: A python client for Egeria
 License: Apache 2.0
 Keywords: egeria,metadata,governance

{pyegeria-5.3.7.7.dist-info → pyegeria-5.3.7.8.dist-info}/RECORD

@@ -1,6 +1,6 @@
 pyegeria/README.md,sha256=PwX5OC7-YSZUCIsoyHh1O-WBM2hE84sm3Bd4O353NOk,1464
-pyegeria/__init__.py,sha256=RcOOkuXLHAKfJ5UOU92rg_Tv0KjIxyhc575sPpw5w5Y,30306
-pyegeria/_client.py,sha256=nhUPmeQFHqbobM6_3EGmUy-STYURxb15BEXf6erY2oI,31733
+pyegeria/__init__.py,sha256=_ajfbBLCVW8RnSWYK4tGXLqjHEdnzCW2q815GENuFS0,30383
+pyegeria/_client.py,sha256=IAX6y11zqX3Dz1XwbYXQqHNdi7HmKQClI0Li5cjUSUA,31884
 pyegeria/_deprecated_gov_engine.py,sha256=dWNcwVsE5__dF2u4QiIyQrssozzzOjBbLld8MdpmVCQ,17264
 pyegeria/_exceptions.py,sha256=1SrnV194V4_YJNnNAU0myTHQ3dhLn4GF2B2gZcj1u90,18153
 pyegeria/_globals.py,sha256=a_irI6oGuBLks2LzQHkSdK6xWbPdJCPRjqxK7PKxwgw,991
@@ -17,12 +17,12 @@ pyegeria/commands/cat/__init__.py,sha256=5OCy4m_yZsnSxdy_gvkCyP_OkjvuWKimqUGHYCJ
 pyegeria/commands/cat/dr_egeria_inbox/glossary_creation_experiment.ipynb,sha256=dbzNu90fCKNohOWVSRBOB1GLyd95x8Qw51I5AkaPtso,11552
 pyegeria/commands/cat/dr_egeria_inbox/glossary_exp.md,sha256=KsUeTzDe5QkrTmIfIAXR74qZ29oSfRW-NAEn0RYIRqM,2534
 pyegeria/commands/cat/dr_egeria_jupyter.py,sha256=U-3m9BMoCXj2fvuawr3PTc2HQWAXThqQ3sIXjyCWv6s,5912
-pyegeria/commands/cat/dr_egeria_md.py,sha256=EdwsDYW6BpIdkBgEn1QC9cenpxV2LmG1unZd_qhS6sc,9898
+pyegeria/commands/cat/dr_egeria_md.py,sha256=-WCnNL3_1hjsYgVy5Z3eixg7MED7O1K0ldfkX7tFpWQ,10378
 pyegeria/commands/cat/exp_list_glossaries.py,sha256=dC6Bnfm3YSMTKPP146qeslIFRiZnGu5b7iDYE07p4iU,5817
 pyegeria/commands/cat/get_asset_graph.py,sha256=xnXJfpDTVH1TJ2TwE3dtjaXU36Di6-N6JAyhothzz2o,12461
 pyegeria/commands/cat/get_collection.py,sha256=kXPcP8u-SMWfrVyyBhNoxG8mcgB7EV_5i9N9w_IBU7o,5379
-pyegeria/commands/cat/get_project_dependencies.py,sha256=wDK_lAfR6p4VxYRV6MZE9XgU3OfIRcWKKYn0Xf64w6o,5986
-pyegeria/commands/cat/get_project_structure.py,sha256=4Jo3F9f7auTnTt_xElsrQ4eA8k8xMge0C5xE-Rjkjcw,5974
+pyegeria/commands/cat/get_project_dependencies.py,sha256=XwstxuDxDDuP2uN1oJi0PTDZVLbqgcc_3lxh_prBZvY,5987
+pyegeria/commands/cat/get_project_structure.py,sha256=5uxWMqNve592OT73GRCO2KoBkgLWRNuQv_emWpS-Fw8,5975
 pyegeria/commands/cat/get_tech_type_elements.py,sha256=IznytHXwDOFriGM6mypV9wuEeM-vT2s66cUzf-IROog,6147
 pyegeria/commands/cat/glossary_actions.py,sha256=SO0PH_Zy34Sbv31FEwCnZalNcxjGVeMT3T352BxSY34,19590
 pyegeria/commands/cat/list_assets.py,sha256=CdJ2coKvvQv2VwJO0Sp9Eg9Fu_uvpC21tgjrdtT9Yz4,6315
@@ -227,26 +227,27 @@ pyegeria/egeria_tech_client.py,sha256=uycgYfCpb4jzFfaQ7I5JxbZ5PKsWdaWxLOJjbw6C2Z
 pyegeria/feedback_manager_omvs.py,sha256=0xBs0p54vmdfVYYgQ8pOanLC4fxfgTk1Z61Y6D1U7_I,152978
 pyegeria/full_omag_server_config.py,sha256=CQqLCy_3DZFvJZEOcGf50HWdFaWpiAIs6z-kKyjvpDA,47464
 pyegeria/glossary_browser_omvs.py,sha256=hkYa5xGV_WXTUAMLx4VjsGhnC7PkVpmVFVcwfUTKDGE,109582
-pyegeria/glossary_manager_omvs.py,sha256=e2b5AjhQ-M_QUMp232VFu6RmptzDWtnLwrEt5t_zoZo,70277
+pyegeria/glossary_manager_omvs.py,sha256=ZJrRUwx3Z1ebbjy60_9PLYh7gAtInE94cPtsPRM7FtM,70273
 pyegeria/m_test.py,sha256=M5-M2ZczsAJLXWfSeqTTADHdx6Ku-y4PbQ4M21JthAE,7778
-pyegeria/md_processing_helpers.py,sha256=XAY5GokE0vKHG1EUaKRgzfGCWStSHrdYPF8NB7MZ3D4,2522
-pyegeria/md_processing_utils.py,sha256=_9_SsjonKKW7c4BIBF7oZYuIjUzZpFNg4Yfx4-ok1aM,60545
-pyegeria/md_processing_utils_orig.py,sha256=e5h7LcD_5DcjtMc6awzgbhKrRF-CQzeyqvk996Kq0rQ,52484
+pyegeria/md_processing_helpers.py,sha256=sV-ciVg_xOGVGTH_CMpH2B5k3V5jzdFp_XvnQQ5xafw,2131
+pyegeria/md_processing_utils.py,sha256=n7PT3wsnv6eLhgnRo_1N3C-HTrHK6459FTsJ1hqgbTU,65055
+pyegeria/md_processing_utils_orig.py,sha256=WGoVpsV03wwgv9YwDDHZ0EO4-opN8BdoISt4ZhkYGuQ,52492
 pyegeria/mermaid_utilities.py,sha256=sQqdFUWdNpHu9d3Tk9UVe80M-5bOzses0XcFYX5FF-E,54254
 pyegeria/metadata_explorer_omvs.py,sha256=xHnZTQKbd6XwOhYia-RiIisrvZcqHi0SL1l6OCf04Gk,86911
 pyegeria/my_profile_omvs.py,sha256=d0oJYCJG7pS9BINPuGciVa00ac0jwPHNANXDCLginEc,34720
 pyegeria/platform_services.py,sha256=YEpZsGGsbSdesN8ceyFhV0OMzKG6znTZrREMTRimLps,41701
-pyegeria/project_manager_omvs.py,sha256=X64JK8Z_jNBX0sxcWoPp8g_iF52ynD_baLN5TGveTAA,67547
+pyegeria/project_manager_omvs.py,sha256=UA-HcLTJ0rAYQXv-l5xLN7hTUinBTsrbwT_MmC8lx0U,70165
 pyegeria/registered_info.py,sha256=y0-LgDIQXpph0lEWxIOG3_HsqX_Z2iAIb3xu4Aa4B70,6344
 pyegeria/runtime_manager_omvs.py,sha256=Z5wY9ignNjil8O6yjihZftxkGoh9A4PQDcXhoIsOIT8,79698
 pyegeria/server_operations.py,sha256=5k0KVz3u8qRLwtz16zT3J86LZY3pkUrMDcps8srmq1A,16831
+pyegeria/shared_state.py,sha256=KqmvWAvct1o6Bte9accfAbI-qAZu-UtCUZiYi7eYYM8,907
 pyegeria/solution_architect_omvs.py,sha256=x6CfPTyn1l2DFYVEFP0t_rT9uVjoFr596hBBeuVaMRg,22093
 pyegeria/template_manager_omvs.py,sha256=PfJ9dOfmBvf59DgRdZ9Dl1Kl_UYqjF-JncXVnbCqLZU,42408
 pyegeria/utils.py,sha256=GCt1C0bp0Xng1ahzbZhzV9qQwH7Dj93IaCt2dvWb-sg,5417
 pyegeria/valid_metadata_omvs.py,sha256=Xq9DqBQvBFFJzaFIRKcVZ2k4gJvSh9yeXs_j-O3vn1w,65050
 pyegeria/x_action_author_omvs.py,sha256=RcqSzahUKCtvb_3u_wyintAlc9WFkC_2v0E12TZs8lQ,6433
-pyegeria-5.3.7.7.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pyegeria-5.3.7.7.dist-info/METADATA,sha256=ufTmNDPpsx1faFqD7VFS7QOqWdxroPVBJpSr_aKhSf4,2740
-pyegeria-5.3.7.7.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-pyegeria-5.3.7.7.dist-info/entry_points.txt,sha256=eAvQ_vkejlF3JzMzEc5VD93ymLA_hSFV0HM8fntG-d8,6791
-pyegeria-5.3.7.7.dist-info/RECORD,,
+pyegeria-5.3.7.8.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyegeria-5.3.7.8.dist-info/METADATA,sha256=4Pjg58x9foW-W7Uq0AbbwL4G2vdRvogrPtjP0ewZHs0,2740
+pyegeria-5.3.7.8.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+pyegeria-5.3.7.8.dist-info/entry_points.txt,sha256=eAvQ_vkejlF3JzMzEc5VD93ymLA_hSFV0HM8fntG-d8,6791
+pyegeria-5.3.7.8.dist-info/RECORD,,