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

pyegeria/md_processing_utils.py

@@ -19,7 +19,7 @@ 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.project_manager_omvs import ProjectManager
 from pyegeria.glossary_manager_omvs import GlossaryManager
 
@@ -27,8 +27,13 @@ from datetime import datetime
 EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "200"))
 console = Console(width=EGERIA_WIDTH)
 
-command_list = ["Provenance", "Create Glossary", "Update Glossary", "Create Term", "Update Term", "Create Personal Project",
-            "Update Personal Project", "Create Category", "Update Category"]
+command_list = ["Provenance",
+                "Create Glossary", "Update Glossary",
+                "Create Term", "Update Term",
+                "Create Personal Project", "Update Personal Project",
+                "Create Category", "Update Category",
+                "Create Solution Blueprint", "Update Solution Blueprint"]
+
 ERROR = "ERROR-> "
 INFO = "INFO- "
 WARNING = "WARNING-> "
@@ -70,12 +75,22 @@ def add_term_to_categories(egeria_client: GlossaryManager, term_guid: str, categ
             egeria_client.add_term_to_category(term_guid, cat_guid)
 
 
-def extract_command(block: str) -> Optional[str]:
+def extract_command_plus(block: str) -> tuple[str, str] | None:
     match = re.search(r"#(.*?)(?:##|\n|$)", block)  # Using a non capturing group
     if match:
-        return match.group(1).strip()
+        clean_match = match.group(1).strip()
+        parts = clean_match.split(' ')
+        object_action = parts[0].strip()
+        # Join the rest of the parts to allow object_type to be one or two words
+        object_type = ' '.join(parts[1:]).strip()
+        return object_type, object_action
     return None
 
+def extract_command(block: str) -> str | None:
+    match = re.search(r"#(.*?)(?:##|\n|$)", block)  # Using a non capturing group
+    if match:
+        return match.group(1).strip()
+    return None
 
 def extract_attribute(text: str, labels: List[str]) -> Optional[str]:
     """
@@ -145,6 +160,378 @@ 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]:
+    """
+    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.
+
+    Parameters:
+    egeria_client: EgeriaTech
+        Client object for interacting with Egeria.
+    element_type: str
+        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.
+
+    Returns: tuple[str, str, str, bool, bool]
+        A tuple containing:
+        - qualified_name: Empty string or element identifier
+        - guid: Empty string or additional element information
+        - msg: Information or error messages about the processing
+        - Valid: Boolean indicating if the element information is valid
+        - Exists: Boolean indicating if the element exists in Egeria
+    """
+
+    msg = ""
+    known_guid = None
+    valid = True
+    exists = False
+    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)
+    else:
+        element_details = get_element_by_name(egeria_client,element_type,display_name)
+
+    if type(element_details) is str:
+        exists = False
+    else:
+        exists = True
+
+    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):
+    """
+    Generalized function to retrieve an element by name based on its type.
+
+    Parameters:
+    egeria_client: Client
+        Client object for interacting with Egeria.
+    element_type: str
+        The type of element to retrieve (e.g., 'blueprint', 'category', 'term').
+    element_name: str
+        The name of the element to retrieve.
+
+    Returns:
+        The element if found, or a string indicating no elements were found.
+    """
+    # 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"
+
+    # 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_blueprint_upsert_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
+                                directive: str = "display") -> Optional[str]:
+    """
+    Processes a blueprint create or update command by extracting key attributes such as
+    blueprint name, description, and version from the given cell.
+
+    Parameters:
+    egeria_client: SolutionArchitect
+        Client object for interacting with Egeria.
+    txt: str
+        A string representing the input cell to be processed for
+        extracting element attributes.
+    directive: str, optional, default "display"
+        An optional string indicating the directive to be used - display, validate or execute
+
+    Returns: str
+        A string summarizing the outcome of the processing.
+    """
+
+    object_type, object_action = extract_command_plus(txt)
+    element_display = ""
+    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)
+
+    if description is None:
+        msg += f"* {INFO}Description is missing\n"
+
+    if version is None:
+        msg += f"* {INFO}Term version is missing\n"
+
+    update_description = extract_attribute(txt, ['Update Description'])
+    if update_description is None:
+        msg += f"* {INFO}Update Description is missing\n"
+        update_description = "---"
+
+    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"\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 directive == "display":
+        print(Markdown(element_display))
+        return None
+    elif directive == "validate":
+        print(Markdown(msg))
+        return valid
+
+    elif directive == "process":
+        print(Markdown(msg))
+        try:
+            if not valid:  # First validate the term before we process it
+                return None
+
+            if object_action == "Update" and directive == "process":
+                if not exists:
+                    print(f"\n-->Blueprint {display_name} does not exist")
+                    return None
+
+                # call update blueprint 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')
+
+            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')
+
+            elif object_action == "Create":
+                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)
+                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}
+                    return 'Would return get blueprint 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}")
+            console.print_exception(show_locals=True)
+            return None
+
+
+
+def process_solution_component_upsert_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
+                                     directive: str = "display") -> Optional[str]:
+    """
+    Processes a solution componentt create or update command by extracting key attributes such as
+    solution component name, description, version, solution component type etc from the given cell.
+
+    Parameters:
+    egeria_client: SolutionArchitect
+        Client object for interacting with Egeria.
+    txt: str
+        A string representing the input cell to be processed for
+        extracting element attributes.
+    directive: str, optional, default "display"
+        An optional string indicating the directive to be used - display, validate or execute
+
+    Returns: str
+        A string summarizing the outcome of the processing.
+    """
+
+    object_type, object_action = extract_command_plus(txt)
+    element_display = ""
+    bp_exist = True
+    display_name = extract_attribute(txt, ['Display Name', 'Solution Component Name'])
+    description = extract_attribute(txt, ['Description'])
+    version = extract_attribute(txt, ['Version', "Version Identifier", "Published Version"])
+    solution_component_type = extract_attribute(txt, ['Solution Component Type'])
+    planned_deployed_implementation_type = extract_attribute(txt, ['Planned Deployment Implementation Type'])
+    solution_blueprints = extract_attribute(txt, ['Solution Blueprints'])
+    parent_components = extract_attribute(txt, ['Parent Components'])
+
+    print(Markdown(
+        f"{pre_command} `{object_type}{object_action}` for Solution Component: `\'{display_name}\'` with directive: `{directive}`"))
+
+    known_q_name, known_guid, msg, valid, exists = process_element_identifiers(egeria_client, object_type,txt)
+
+    if description is None:
+        msg += f"* {INFO}Description is missing\n"
+
+    if version is None:
+        msg += f"* {INFO}Term version is missing\n"
+
+    update_description = extract_attribute(txt, ['Update Description'])
+    if update_description is None:
+        msg += f"* {INFO}Update Description is missing\n"
+        update_description = "---"
+
+    if solution_component_type is None:
+        msg += f"* {INFO}Solution Component Type is missing\n"
+
+    if planned_deployed_implementation_type is None:
+        msg += f"* {INFO}Planned Deployed Implementation Type is missing\n"
+
+    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
+
+    if parent_components is None:
+        msg += f"* {INFO}Parent Components are missing\n"
+
+    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"\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 directive == "display":
+        print(Markdown(element_display))
+        return None
+    elif directive == "validate":
+        print(Markdown(msg))
+        return valid
+
+    elif directive == "process":
+        print(Markdown(msg))
+        try:
+            if not valid:  # First validate the term before we process it
+                return None
+
+            if object_action == "Update" and directive == "process":
+                if not exists:
+                    print(f"\n-->Blueprint {display_name} does not exist")
+                    return None
+
+                # call update blueprint 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')
+
+            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')
+
+            elif object_action == "Create":
+                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)
+                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}
+                    return 'Would return get blueprint 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}")
+            console.print_exception(show_locals=True)
+            return None
+
 
 def process_glossary_upsert_command(egeria_client: GlossaryManager, element_dictionary: dict, txt: str,
                                     directive: str = "display") -> Optional[str]:
@@ -161,7 +548,7 @@ def process_glossary_upsert_command(egeria_client: GlossaryManager, element_dict
     object_type = command.split(' ')[1].strip()
     object_action = command.split(' ')[0].strip()
 
-    glossary_name = extract_attribute(txt, ['Glossary Name'])
+    glossary_name = extract_attribute(txt, ['Glossary Name','Display Name'])
     print(Markdown(f"{pre_command} `{command}` for glossary: `\'{glossary_name}\'` with directive: `{directive}` "))
     language = extract_attribute(txt, ['Language'])
     description = extract_attribute(txt, ['Description'])
@@ -177,16 +564,11 @@ def process_glossary_upsert_command(egeria_client: GlossaryManager, element_dict
         glossary_display += f"* Qualified Name: {q_name}\n\t* GUID: {guid}\n\n"
 
     def validate_glossary(obj_action: str) -> tuple[bool, bool, Optional[str], Optional[str]]:
+
         valid = True
         msg = ""
-        known_glossary_guid = None
-        known_q_name = None
 
-        glossary_details = egeria_client.get_glossaries_by_name(glossary_name)
-        if glossary_details == NO_GLOSSARIES_FOUND:
-            glossary_exists = False
-        else:
-            glossary_exists = True
+        known_q_name, known_guid, msg, valid, glossary_exists = process_element_identifiers(egeria_client, object_type,txt)
 
         if glossary_name is None:
             msg = f"* {ERROR}Glossary name is missing\n"
@@ -197,13 +579,6 @@ def process_glossary_upsert_command(egeria_client: GlossaryManager, element_dict
         if description is None:
             msg += f"* {INFO}Description is missing\n"
 
-        if len(glossary_details) > 1 and glossary_exists:
-            msg += f"* {ERROR}More than one glossary with name {glossary_name} found\n"
-            valid = False
-        if len(glossary_details) == 1:
-            known_glossary_guid = glossary_details[0]['elementHeader'].get('guid', None)
-            known_q_name = glossary_details[0]['glossaryProperties'].get('qualifiedName', None).strip()
-
         if obj_action == "Update":
 
             if not glossary_exists:
@@ -220,12 +595,12 @@ 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_glossary_guid}
+                element_dictionary[known_q_name] = {'display_name': glossary_name, 'guid': known_guid}
             else:
                 msg += f"* --> validation failed\n"
 
             print(Markdown(msg))
-            return valid, glossary_exists, known_glossary_guid, known_q_name
+            return valid, glossary_exists, known_guid, known_q_name
 
         elif obj_action == "Create":
             if glossary_exists:
@@ -238,7 +613,7 @@ def process_glossary_upsert_command(egeria_client: GlossaryManager, element_dict
                 element_dictionary[expected_q_name] = {'display_name': glossary_name}
 
             print(Markdown(msg))
-            return valid, glossary_exists, known_glossary_guid, known_q_name
+            return valid, glossary_exists, known_guid, known_q_name
 
     if directive == "display":
         print(Markdown(glossary_display))
@@ -479,7 +854,7 @@ def process_term_upsert_command(egeria_client: GlossaryManager, element_dictiona
     object_type = command.split(' ')[1].strip()
     object_action = command.split(' ')[0].strip()
 
-    term_name = extract_attribute(txt, ['Term Name'])
+    term_name = extract_attribute(txt, ['Term Name','Display Name'])
     summary = extract_attribute(txt, ['Summary'])
     description = extract_attribute(txt, ['Description'])
     abbreviation = extract_attribute(txt, ['Abbreviation'])
@@ -630,9 +1005,11 @@ def process_term_upsert_command(egeria_client: GlossaryManager, element_dictiona
                 msg += f"\n-->Validation checks failed in creating Term \'{term_name}\' with: {term_display}\n"
             else:
                 msg += f"\n-->It is valid to create Term \'{term_name}\' with: {term_display}\n"
-                expected_q_name = egeria_client.__create_qualified_name__('Term', term_name)
-                element_dictionary[expected_q_name] = {'display_name': term_name}
-
+                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}
+                else:
+                    element_dictionary[q_name] = {'display_name': term_name}
             print(Markdown(msg))
             return valid, term_exists, known_term_guid, known_q_name
 
@@ -645,8 +1022,8 @@ def process_term_upsert_command(egeria_client: GlossaryManager, element_dictiona
         update_description = extract_attribute(txt, 'Update Description')
         update_description = update_description if update_description else " "
         term_display = (f"\n* Command: {command}\n\t* Glossary: {glossary_qn}\n\t"
-                        f"* Term Name: {term_name}\n\t* Categories: {categories}\n\t* Summary: {summary}"
-                        f"\n\t* Description: {description}\n\t"
+                        f"* Term Name: {term_name}\n\t* Qualified Name: {q_name}\n\t* Categories: {categories}\n\t"
+                        f"* Summary: {summary}\n\t* Description: {description}\n\t"
                         f"* Abbreviation: {abbreviation}\n\t* Examples: {examples}\n\t* Usage: {usage}\n\t"
                         f"* Version: {version}\n\t* Status: {status}\n\t* GUID: {term_guid}\n\t* Qualified Name: "
                         f"{q_name}"
@@ -654,7 +1031,7 @@ def process_term_upsert_command(egeria_client: GlossaryManager, element_dictiona
     else:
         term_display = (f"\n* Command: {command}\n\t* Glossary: {glossary_qn}\n\t"
                         f"* Term Name: {term_name}\n\t* Categories: {categories}\n\t* Summary: {summary}\n\t"
-                        f"* Description: {description}\n\t"
+                        f"* Qualified Name: {q_name}\n\t* Description: {description}\n\t"
                         f"* Abbreviation: {abbreviation}\n\t* Examples: {examples}\n\t* Usage: {usage}\n\t"
                         f"* Version: {version}\n\t* Status: {status}\n")
 
@@ -708,8 +1085,8 @@ def process_term_upsert_command(egeria_client: GlossaryManager, element_dictiona
 
             elif object_action == "Create":
                 guid = None
-
-                q_name = egeria_client.__create_qualified_name__("Term",term_name)
+                if q_name is None:
+                    q_name = egeria_client.__create_qualified_name__("Term",term_name)
                 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)