pyegeria 5.3.9.5__py3-none-any.whl → 5.3.9.6__py3-none-any.whl

pyegeria/md_processing/utils/display_utils.py

@@ -1,53 +0,0 @@
-"""
-This file contains display-related constants and formatting functions for Egeria Markdown processing
-"""
-
-# Constants for element labels
-GLOSSARY_NAME_LABELS = ["Glossary Name", "Glossary", "Glossaries", "Owning Glossary", "In Glossary"]
-CATEGORY_NAME_LABELS = ["Glossary Category Name", "Glossary Category", "Glossary Categories", "Category Name",
-                        "Category", "Categories"]
-PARENT_CATEGORY_LABELS = ["Parent Category Name", "Parent Category", "parent category name", "parent category"]
-CHILD_CATEGORY_LABELS = ["Child Categories", "Child Category", "child category names", "child categories",
-                         "Child Category Names"]
-TERM_NAME_LABELS = ["Glossary Term Name", "Glossary Term", "Glossary Terms", "Term Name", "Term", "Terms", "Term Names"]
-PROJECT_NAME_LABELS = ["Project Name", "Project", "Project Names", "Projects"]
-BLUEPRINT_NAME_LABELS = ["Solution Blueprint Name", "Solution Blueprint", "Solution Blueprints", "Blueprint Name",
-                         "Blueprint", "Blueprints"]
-COMPONENT_NAME_LABELS = ["Solution Component Name", "Solution Component", "Solution Components", "Component Name",
-                         "Component", "Components", "Parent Components", "Parent Component"]
-SOLUTION_ROLE_LABELS = ["Solution Role Name", "Solution Role", "Solution Roles", "Role Name", "Role", "Roles"]
-SOLUTION_ACTOR_ROLE_LABELS = ["Solution Actor Role Name", "Solution Actor Role Names", "Solution Actor Role",
-                              "Solution Actor Roles", "Actor Role Name", "Actor Role", "Actor Roles",
-                              "Actor Role Names"]
-SOLUTION_LINKING_ROLE_LABELS = ["Solution Linking Role Name", "Solution Linking Role Names", "Solution Linking Role",
-                                "Solution Linking Roles", "Linking Role Name", "Linking Role", "Linking Roles",
-                                "Linking Role Names"]
-OUTPUT_LABELS = ["Output", "Output Format"]
-SEARCH_LABELS = ['Search String', 'Filter']
-GUID_LABELS = ['GUID', 'guid']
-
-# Constants for output formats
-ELEMENT_OUTPUT_FORMATS = ["LIST", "DICT", "MD", "FORM", "REPORT"]
-
-# Constants for term relationships
-TERM_RELATIONSHPS = [
-    "Synonym",
-    "Translation",
-    "PreferredTerm",
-    "TermISATYPEOFRelationship",
-    "TermTYPEDBYRelationship",
-    "Antonym",
-    "ReplacementTerm",
-    "ValidValue",
-    "TermHASARelationship",
-    "RelatedTerm",
-    "ISARelationship"
-]
-
-# List of supported commands
-command_list = ["Provenance", "Create Glossary", "Update Glossary", "Create Term", "Update Term", "List Terms", "List Term Details",
-                "List Glossary Terms", "List Term History", "List Term Revision History", "List Term Update History",
-                "List Glossary Structure", "List Glossaries", "List Categories", "List Glossary Categories",
-                "Create Personal Project", "Update Personal Project", "Create Category", "Update Category",
-                "Create Solution Blueprint", "Update Solution Blueprint", "Create Solution Component",
-                "Update Solution Component", "Create Term-Term Relationship", "Update Term-Term Relationship",]

pyegeria/md_processing/utils/extraction_utils.py

@@ -1,177 +0,0 @@
-"""
-This file contains functions for extracting data from text for Egeria Markdown processing
-"""
-import re
-from typing import List, Optional, Any, Tuple
-
-from pyegeria.md_processing.utils.common_utils import print_msg, INFO
-
-def extract_command_plus(block: str) -> tuple[str, str, str] | None:
-    """
-    Extracts a multi-word object and its associated action from the given block of text.
-
-    This function searches for a pattern in the format of `#...##` or `#...\n`
-    inside the provided string `block`. The matched pattern is split into
-    two parts: the action and the object type. The action is expected to
-    be the first part, while the rest is treated as the object type. If
-    no match is found, the function returns None.
-
-    Lines beginning with '>' are ignored.
-
-    Args:
-        block: A string containing the block of text to search for the
-            command and action.
-
-    Returns:
-        A tuple containing the command, the object type and the object action if a
-        match is found. Otherwise, returns None.
-    """
-    # Filter out lines beginning with '>'
-    filtered_lines = [line for line in block.split('\n') if not line.strip().startswith('>')]
-    filtered_block = '\n'.join(filtered_lines)
-
-    match = re.search(r"#(.*?)(?:##|\n|$)", filtered_block)  # Using a non capturing group
-    if match:
-        clean_match = match.group(1).strip()
-        if ' ' in clean_match:
-            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()
-        else:
-            object_type = clean_match.split(' ')[1].strip()
-            object_action = clean_match.split(' ')[0].strip()
-
-        return clean_match, object_type, object_action
-    return None
-
-
-def extract_command(block: str) -> str | None:
-    """
-    Extracts a command from a block of text that is contained between a single hash ('#') and
-    either a double hash ('##'), a newline character, or the end of the string.
-
-    The function searches for a specific pattern within the block of text and extracts the
-    content that appears immediately after a single hash ('#'). Ensures that the extracted
-    content is appropriately trimmed of leading or trailing whitespace, if present.
-
-    Args:
-        block: A string representing the block of text to process. Contains the content
-            in which the command and delimiters are expected to be present.
-
-    Returns:
-        The extracted command as a string if a match is found, otherwise 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]) -> str | None:
-    """
-        Extracts the attribute value from a string.
-
-        Args:
-            text: The input string.
-            labels: List of equivalent labels to search for
-
-        Returns:
-            The value of the attribute, or None if not found.
-
-        Note:
-            Lines beginning with '>' are ignored.
-        """
-    # Iterate over the list of labels
-    for label in labels:
-        # Construct pattern for the current label
-        pattern = rf"## {re.escape(label)}\n(.*?)(?:#|___|>|$)"  # modified from --- to enable embedded tables
-        match = re.search(pattern, text, re.DOTALL)
-        if match:
-            # Extract matched text
-            matched_text = match.group(1).strip()
-
-            # Filter out lines beginning with '>'
-            filtered_lines = [line for line in matched_text.split('\n') if not line.strip().startswith('>')]
-            filtered_text = '\n'.join(filtered_lines)
-
-            # Replace consecutive \n with a single \n
-            extracted_text = re.sub(r'\n+', '\n', filtered_text)
-            if not extracted_text.isspace() and extracted_text:
-                return extracted_text  # Return the cleaned text - I removed the title casing
-
-    return None
-
-
-def process_simple_attribute(txt: str, labels: list[str], if_missing: str = INFO) -> str | None:
-    """
-    Processes a simple attribute from a string.
-
-    Args:
-        txt: The input string.
-        labels: List of equivalent labels to search for
-        if_missing: The message level to use if the attribute is missing.
-
-    Returns:
-        The value of the attribute, or None if not found.
-    """
-    from pyegeria.md_processing.utils.common_utils import debug_level, print_msg
-
-    attribute = extract_attribute(txt, labels)
-    if attribute is None and if_missing:
-        msg = f"No {labels[0]} found"
-        print_msg(if_missing, msg, debug_level)
-    return attribute
-
-
-def process_name_list(egeria_client, element_type: str, txt: str, element_labels: list[str]) -> tuple[list, list, bool, bool]:
-    """
-    Processes a list of names from a string.
-
-    Args:
-        egeria_client: The Egeria client to use for validation.
-        element_type: The type of element to process.
-        txt: The input string.
-        element_labels: List of equivalent labels to search for
-
-    Returns:
-        A tuple containing:
-        - A list of element names
-        - A list of element qualified names
-        - A boolean indicating if all elements are valid
-        - A boolean indicating if any elements exist
-    """
-    from pyegeria.md_processing.utils.common_utils import debug_level, print_msg
-    from pyegeria.md_processing.utils.validation_utils import get_element_by_name
-
-    element_names = []
-    element_q_names = []
-    all_valid = True
-    any_exist = False
-
-    # Get the list of element names
-    element_list = process_simple_attribute(txt, element_labels)
-    if element_list:
-        # Split the list by commas or newlines
-        element_names = list(filter(None, re.split(r'[,\n]+', element_list.strip())))
-        
-        # Validate each element
-        for element_name in element_names:
-            element_name = element_name.strip()
-            if element_name:
-                element = get_element_by_name(egeria_client, element_type, element_name)
-                if element:
-                    any_exist = True
-                    element_q_name = element.get('qualifiedName', None)
-                    if element_q_name:
-                        element_q_names.append(element_q_name)
-                    else:
-                        all_valid = False
-                        msg = f"Element {element_name} has no qualified name"
-                        print_msg("ERROR", msg, debug_level)
-                else:
-                    all_valid = False
-                    msg = f"Element {element_name} not found"
-                    print_msg("ERROR", msg, debug_level)
-
-    return element_names, element_q_names, all_valid, any_exist

pyegeria/md_processing/utils/validation_utils.py

@@ -1,208 +0,0 @@
-"""
-This file contains functions for validating data for Egeria Markdown processing
-"""
-import re
-from typing import List, Optional, Any, Tuple
-
-from pyegeria._globals import NO_ELEMENTS_FOUND
-from pyegeria.dr_egeria_state import get_element_dictionary, update_element_dictionary, find_key_with_value
-
-def process_element_identifiers(egeria_client, element_type: str, element_labels: list[str], txt: str, action: str, version: str = None) -> tuple[str, str, bool, bool]:
-    """
-    Processes element identifiers from a string.
-
-    Args:
-        egeria_client: The Egeria client to use for validation.
-        element_type: The type of element to process.
-        element_labels: List of equivalent labels to search for
-        txt: The input string.
-        action: The action to perform (Create, Update, or Exists Required).
-        version: The version of the element.
-
-    Returns:
-        A tuple containing:
-        - The qualified name of the element
-        - The GUID of the element
-        - A boolean indicating if the element is valid
-        - A boolean indicating if the element exists
-    """
-    from pyegeria.md_processing.utils.common_utils import debug_level, print_msg, EXISTS_REQUIRED
-    from pyegeria.md_processing.utils.extraction_utils import process_simple_attribute
-
-    element_name = process_simple_attribute(txt, element_labels)
-    if element_name is None:
-        return None, None, False, False
-
-    element = get_element_by_name(egeria_client, element_type, element_name)
-    if element is None:
-        if action == EXISTS_REQUIRED or action == "Update":
-            msg = f"{element_type} {element_name} not found"
-            print_msg("ERROR", msg, debug_level)
-            return None, None, False, False
-        else:
-            return None, None, True, False
-    else:
-        element_guid = element.get('guid', None)
-        element_q_name = element.get('qualifiedName', None)
-        if element_guid and element_q_name:
-            if action == "Create":
-                msg = f"{element_type} {element_name} already exists with GUID {element_guid}"
-                print_msg("WARNING", msg, debug_level)
-            else:
-                msg = f"{element_type} {element_name} exists with GUID {element_guid}"
-                print_msg("INFO", msg, debug_level)
-            return element_q_name, element_guid, True, True
-        else:
-            msg = f"{element_type} {element_name} exists but has no GUID or qualified name"
-            print_msg("ERROR", msg, debug_level)
-            return None, None, False, True
-
-
-def get_element_by_name(egeria_client, element_type: str, element_name: str) -> dict | None:
-    """
-    Gets an element by name.
-
-    Args:
-        egeria_client: The Egeria client to use for validation.
-        element_type: The type of element to get.
-        element_name: The name of the element to get.
-
-    Returns:
-        The element if found, otherwise None.
-    """
-    from pyegeria.md_processing.utils.common_utils import debug_level, print_msg
-    from pyegeria.md_processing.utils.display_utils import (
-        GLOSSARY_NAME_LABELS, CATEGORY_NAME_LABELS, TERM_NAME_LABELS, PROJECT_NAME_LABELS,
-        BLUEPRINT_NAME_LABELS, COMPONENT_NAME_LABELS
-    )
-
-    # Check if we already have this element in our dictionary
-    element_dict = get_element_dictionary()
-    if element_dict:
-        for q_name, details in element_dict.items():
-            if details.get('display_name', '').lower() == element_name.lower():
-                if element_type.lower() in q_name.lower():
-                    msg = f"Found {element_type} {element_name} in dictionary with qualified name {q_name}"
-                    print_msg("DEBUG-INFO", msg, debug_level)
-                    return {'qualifiedName': q_name, 'guid': details.get('guid', None)}
-
-    # If not in dictionary, query Egeria
-    try:
-        if element_type in GLOSSARY_NAME_LABELS:
-            glossaries = egeria_client.list_glossaries()
-            if glossaries == NO_ELEMENTS_FOUND:
-                return None
-            for glossary in glossaries:
-                if glossary.get('displayName', '').lower() == element_name.lower():
-                    q_name = glossary.get('qualifiedName', None)
-                    guid = glossary.get('guid', None)
-                    if q_name and guid:
-                        update_element_dictionary(q_name, {'guid': guid, 'display_name': element_name})
-                        return {'qualifiedName': q_name, 'guid': guid}
-        elif element_type in CATEGORY_NAME_LABELS:
-            categories = egeria_client.list_categories()
-            if categories == NO_ELEMENTS_FOUND:
-                return None
-            for category in categories:
-                if category.get('displayName', '').lower() == element_name.lower():
-                    q_name = category.get('qualifiedName', None)
-                    guid = category.get('guid', None)
-                    if q_name and guid:
-                        update_element_dictionary(q_name, {'guid': guid, 'display_name': element_name})
-                        return {'qualifiedName': q_name, 'guid': guid}
-        elif element_type in TERM_NAME_LABELS:
-            terms = egeria_client.list_terms()
-            if terms == NO_ELEMENTS_FOUND:
-                return None
-            for term in terms:
-                if term.get('displayName', '').lower() == element_name.lower():
-                    q_name = term.get('qualifiedName', None)
-                    guid = term.get('guid', None)
-                    if q_name and guid:
-                        update_element_dictionary(q_name, {'guid': guid, 'display_name': element_name})
-                        return {'qualifiedName': q_name, 'guid': guid}
-        elif element_type in PROJECT_NAME_LABELS:
-            projects = egeria_client.list_projects()
-            if projects == NO_ELEMENTS_FOUND:
-                return None
-            for project in projects:
-                if project.get('displayName', '').lower() == element_name.lower():
-                    q_name = project.get('qualifiedName', None)
-                    guid = project.get('guid', None)
-                    if q_name and guid:
-                        update_element_dictionary(q_name, {'guid': guid, 'display_name': element_name})
-                        return {'qualifiedName': q_name, 'guid': guid}
-        elif element_type in BLUEPRINT_NAME_LABELS:
-            blueprints = egeria_client.list_solution_blueprints()
-            if blueprints == NO_ELEMENTS_FOUND:
-                return None
-            for blueprint in blueprints:
-                if blueprint.get('displayName', '').lower() == element_name.lower():
-                    q_name = blueprint.get('qualifiedName', None)
-                    guid = blueprint.get('guid', None)
-                    if q_name and guid:
-                        update_element_dictionary(q_name, {'guid': guid, 'display_name': element_name})
-                        return {'qualifiedName': q_name, 'guid': guid}
-        elif element_type in COMPONENT_NAME_LABELS:
-            components = egeria_client.list_solution_components()
-            if components == NO_ELEMENTS_FOUND:
-                return None
-            for component in components:
-                if component.get('displayName', '').lower() == element_name.lower():
-                    q_name = component.get('qualifiedName', None)
-                    guid = component.get('guid', None)
-                    if q_name and guid:
-                        update_element_dictionary(q_name, {'guid': guid, 'display_name': element_name})
-                        return {'qualifiedName': q_name, 'guid': guid}
-    except Exception as e:
-        msg = f"Error getting {element_type} {element_name}: {e}"
-        print_msg("ERROR", msg, debug_level)
-        return None
-
-    return None
-
-
-def update_a_command(txt: str, command: str, obj_type: str, q_name: str, u_guid: str) -> str:
-    """
-    Updates a command in a string.
-
-    Args:
-        txt: The input string.
-        command: The command to update.
-        obj_type: The type of object to update.
-        q_name: The qualified name of the object.
-        u_guid: The GUID of the object.
-
-    Returns:
-        The updated string.
-    """
-    # Split the command into action and object
-    parts = command.split()
-    action = parts[0]
-    
-    # Determine the new action
-    new_action = "Update" if action == "Create" else "Create"
-    
-    # Replace the command
-    new_command = f"{new_action} {obj_type}"
-    pattern = rf"#{command}(?:##|\n|$)"
-    replacement = f"#{new_command}\n"
-    updated_txt = re.sub(pattern, replacement, txt)
-    
-    # Add qualified name and GUID if updating
-    if new_action == "Update" and q_name and u_guid:
-        # Check if Qualified Name section exists
-        if "## Qualified Name" not in updated_txt:
-            # Add Qualified Name section before the first ## that's not part of the command
-            pattern = r"(##\s+[^#\n]+)"
-            replacement = f"## Qualified Name\n{q_name}\n\n\\1"
-            updated_txt = re.sub(pattern, replacement, updated_txt, count=1)
-        
-        # Check if GUID section exists
-        if "## GUID" not in updated_txt and "## guid" not in updated_txt:
-            # Add GUID section before the first ## that's not part of the command or Qualified Name
-            pattern = r"(##\s+(?!Qualified Name)[^#\n]+)"
-            replacement = f"## GUID\n{u_guid}\n\n\\1"
-            updated_txt = re.sub(pattern, replacement, updated_txt, count=1)
-    
-    return updated_txt