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

pyegeria/md_processing/commands/term_commands.py

@@ -0,0 +1,524 @@
+"""
+This file contains term-related command functions for processing Egeria Markdown
+"""
+import re
+from typing import Optional, List
+
+from rich.markdown import Markdown
+from rich.console import Console
+
+from pyegeria.egeria_tech_client import EgeriaTech
+from pyegeria.md_processing.utils.common_utils import (
+    debug_level, print_msg, ALWAYS, ERROR, INFO, WARNING, pre_command, command_seperator, EXISTS_REQUIRED
+)
+from pyegeria.md_processing.utils.extraction_utils import (
+    extract_command_plus, extract_command, process_simple_attribute, process_name_list
+)
+from pyegeria.md_processing.utils.validation_utils import (
+    process_element_identifiers, update_a_command
+)
+from pyegeria.md_processing.utils.display_utils import (
+    GLOSSARY_NAME_LABELS, CATEGORY_NAME_LABELS, TERM_NAME_LABELS, OUTPUT_LABELS, ELEMENT_OUTPUT_FORMATS, 
+    SEARCH_LABELS, GUID_LABELS, TERM_RELATIONSHPS
+)
+from pyegeria.dr_egeria_state import update_element_dictionary
+
+def update_term_categories(egeria_client: EgeriaTech, term_guid: str, current_categories: List[str], new_categories: List[str]) -> None:
+    """
+    Updates the categories of a term.
+
+    Args:
+        egeria_client: The Egeria client to use for the update.
+        term_guid: The GUID of the term to update.
+        current_categories: The current categories of the term.
+        new_categories: The new categories of the term.
+    """
+    if new_categories:  # If categories are specified, add them
+        for cat in new_categories:
+            if cat not in current_categories:
+                egeria_client.add_term_to_category(term_guid, cat)
+                msg = f"Added term {term_guid} to category {cat}"
+                print_msg("DEBUG-INFO", msg, debug_level)
+        # Remove any categories that are not in the new list
+        for cat in current_categories:
+            if cat not in new_categories:
+                egeria_client.remove_term_from_category(term_guid, cat)
+                msg = f"Removed term {term_guid} from category {cat}"
+                print_msg("DEBUG-INFO", msg, debug_level)
+    else:  # No categories specified - so remove any categories a term is in
+        for cat in current_categories:
+            egeria_client.remove_term_from_category(term_guid, cat)
+            msg = f"Removed term {term_guid} from category {cat}"
+            print_msg("DEBUG-INFO", msg, debug_level)
+
+
+def process_term_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+    """
+    Processes a term create or update command by extracting key attributes such as
+    term name, summary, description, abbreviation, examples, usage, version, and status from the given cell.
+
+    :param txt: A string representing the input cell to be processed for
+        extracting glossary-related attributes.
+    :param directive: an optional string indicating the directive to be used - display, validate or execute
+    :return: A string summarizing the outcome of the processing.
+    """
+    from pyegeria.md_processing.utils.common_utils import set_debug_level
+
+    valid = True
+    categories_list = None
+    cats_exist = False
+    set_debug_level(directive)
+    known_q_name = None
+    command = extract_command(txt)
+    object_type = command.split(' ')[1].strip()
+    object_action = command.split(' ')[0].strip()
+
+    term_name = process_simple_attribute(txt, ['Term Name', 'Display Name'], ERROR)
+    print(Markdown(f"{pre_command} `{command}` for term:`{term_name}` with directive: `{directive}`"))
+    summary = process_simple_attribute(txt, ['Summary'],INFO)
+    description = process_simple_attribute(txt, ['Description'], INFO)
+    abbreviation = process_simple_attribute(txt, ['Abbreviation'], INFO)
+    examples = process_simple_attribute(txt, ['Examples'], INFO)
+    usage = process_simple_attribute(txt, ['Usage'], INFO)
+    status = process_simple_attribute(txt, ['Status'])
+    status = status.upper() if status else 'DRAFT'
+    version = process_simple_attribute(txt, ['Version', "Version Identifier", "Published Version"], INFO)
+    q_name = process_simple_attribute(txt, ['Qualified Name'], INFO)
+
+    aliases = process_simple_attribute(txt, ['Aliases','Alias'], INFO)
+    if aliases:
+        alias_list = list(filter(None, re.split(r'[,\n]+', aliases.strip())))
+    else:
+        alias_list = None
+
+
+    # validate term name and get existing qualified_name and guid if they exist
+    if term_name is None:
+        valid = False
+        known_q_name, known_guid, term_exists = None, None, False
+    else:
+        element_labels = TERM_NAME_LABELS
+        element_labels.append('Display Name')
+        known_q_name, known_guid, valid, term_exists = process_element_identifiers(egeria_client, object_type,
+                                                                                   element_labels, txt, object_action,
+                                                                                   version)
+
+    # get the glossary qualified name this term is in
+    glossary_name = process_simple_attribute(txt, GLOSSARY_NAME_LABELS, ERROR)
+    if glossary_name is None:
+        valid = False
+        known_glossary_guid = None
+        known_glossary_q_name = None
+        glossary_valid = False
+        glossary_exists = False
+    else:
+        known_glossary_q_name, known_glossary_guid, glossary_valid, glossary_exists = process_element_identifiers(
+            egeria_client, "Glossary", GLOSSARY_NAME_LABELS, txt, EXISTS_REQUIRED, None)
+
+    # process categories, if present
+    categories = process_simple_attribute(txt, ['Glossary Categories', 'Glossary Category', 'Category', 'Categories'])
+    if categories:  # Find information about categoriess that classify this term
+        msg = "Checking for categories that classify this term"
+        print_msg("DEBUG-INFO", msg, debug_level)
+        categories_list, cat_q_name_list, cats_valid, cats_exist = process_name_list(egeria_client, 'Glossary Categories',
+                                                                                   txt, CATEGORY_NAME_LABELS)
+        if cats_exist and cats_valid:
+            msg = f"Found valid glossary categories to classify the term:\n\t{term_name}"
+            print_msg("INFO", msg, debug_level)
+        else:
+            msg = "No valid glossary categories found."
+            print_msg("INFO", msg, debug_level)
+    else:
+        cats_exist = cats_valid = False
+        cat_q_name_list = None
+
+    if object_action == "Update":  # check to see if provided information exists and is consistent with existing info
+        term_guid = process_simple_attribute(txt, GUID_LABELS)
+        update_description = process_simple_attribute(txt, ['Update Description'])
+        term_display = (f"\n* Command: {command}\n\t* Glossary: {known_glossary_q_name}\n\t"
+                        f"* Term Name: {term_name}\n\t* Qualified Name: {q_name}\n\t* Aliases: {aliases}\n\t"
+                        f"* 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}"
+                        f"\n\t* Update Description: {update_description}\n")
+        if not term_exists:
+            msg = f"Update request invalid, Term {term_name} does not exist\n"
+            print_msg(ERROR, msg, debug_level)
+            valid = False
+
+    elif object_action == 'Create':  # if the command is create, check that it doesn't already exist
+        term_display = (f"\n* Command: {command}\n\t* Glossary: {known_glossary_q_name}\n\t"
+                        f"* Term Name: {term_name}\n\t* Categories: {categories}\n\t* Summary: {summary}\n\t"
+                        f"* Qualified Name: {q_name}\n\t* Aliases: {aliases}\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")
+        if term_exists:
+            msg = f"Term `{term_name}` cannot be created since it already exists\n"
+            print_msg(ERROR, msg, debug_level)
+        else:
+            msg = f"It is valid to create Term `{term_name}`"
+            print_msg(ALWAYS, msg, debug_level)
+
+    if directive == "display":
+        print(Markdown(term_display))
+        return None
+    elif directive == "validate":
+        if valid:
+            print(Markdown(term_display))
+        else:
+            msg = f"Validation failed for Term `{term_name}`\n"
+            print_msg(ERROR, msg, debug_level)
+            print(Markdown(term_display))
+        return valid
+    elif directive == "process":
+        if valid:
+            print(Markdown(term_display))
+        else:
+            if term_exists and object_action == "Create":
+                msg = f"Create failed because term `{term_name}` exists - changing `Create` to `Update` in processed output \n"
+                print_msg(ERROR, msg, debug_level)
+                print(Markdown(term_display))
+                return update_a_command(txt, command, object_type, known_q_name, known_guid)
+            else:
+                return None
+
+        try:
+            if object_action == "Update":
+                if not term_exists:
+                    print(f"\n{ERROR}Term `{term_name}` does not exist! Updating result document with Create "
+                          f"command\n")
+                    return update_a_command(txt, command, object_type, known_q_name, known_guid)
+
+                body = {
+                    "class": "ReferenceableRequestBody", "elementProperties": {
+                        "class": "GlossaryTermProperties", "qualifiedName": known_q_name, "summary": summary,
+                        "description": description, "abbreviation": abbreviation, "examples": examples,
+                        "usage": usage, "status": status
+                        }
+                    }
+                egeria_client.update_term(known_guid, body)
+                print_msg(ALWAYS, f"Updated Term `{term_name}` with GUID {known_guid}", debug_level)
+                update_element_dictionary(known_q_name, {
+                    'guid': known_guid, 'display_name': term_name
+                    })
+
+                # Update categories if specified
+                if categories:
+                    # Get the current categories
+                    term_details = egeria_client.get_term_by_guid(known_guid)
+                    current_categories = []
+                    if 'categories' in term_details:
+                        for cat in term_details['categories']:
+                            current_categories.append(cat.get('guid', None))
+                    # Update the categories
+                    update_term_categories(egeria_client, known_guid, current_categories, cat_q_name_list)
+
+                # Update aliases if specified
+                if alias_list:
+                    # Get the current aliases
+                    term_details = egeria_client.get_term_by_guid(known_guid)
+                    current_aliases = term_details.get('aliases', [])
+                    # Add new aliases
+                    for alias in alias_list:
+                        if alias not in current_aliases:
+                            egeria_client.add_term_alias(known_guid, alias)
+                    # Remove aliases that are not in the new list
+                    for alias in current_aliases:
+                        if alias not in alias_list:
+                            egeria_client.remove_term_alias(known_guid, alias)
+
+                return egeria_client.get_term_by_guid(known_guid, output_format='MD')
+
+            elif object_action == "Create":
+                if term_exists:
+                    print(f"\nTerm `{term_name}` already exists and result document updated\n")
+                    return update_a_command(txt, command, object_type, known_q_name, known_guid)
+                else:
+                    term_guid = egeria_client.create_term(term_name, summary, description, glossary_name=glossary_name,
+                                                         status=status, abbreviation=abbreviation, examples=examples,
+                                                         usage=usage, aliases=alias_list)
+                    if term_guid:
+                        print_msg(ALWAYS, f"Created Term `{term_name}` with GUID {term_guid}", debug_level)
+                        # Add categories if specified
+                        if categories and cats_exist and cats_valid:
+                            update_term_categories(egeria_client, term_guid, [], cat_q_name_list)
+                        return egeria_client.get_term_by_guid(term_guid, output_format='MD')
+                    else:
+                        print_msg(ERROR, f"Failed to create Term `{term_name}`", debug_level)
+                        return None
+
+        except Exception as e:
+            print(f"{ERROR}Error performing {command}: {e}")
+            Console().print_exception(show_locals=True)
+            return None
+    else:
+        return None
+
+
+def process_create_term_term_relationship_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+    """
+    Processes a term-term relationship create command by extracting key attributes such as
+    term names and relationship type from the given text.
+
+    :param txt: A string representing the input cell to be processed for
+        extracting term relationship attributes.
+    :param directive: an optional string indicating the directive to be used - display, validate or execute
+    :return: A string summarizing the outcome of the processing.
+    """
+    from pyegeria.md_processing.utils.common_utils import set_debug_level
+
+    command = extract_command(txt)
+    set_debug_level(directive)
+    print(Markdown(f"{pre_command} `{command}` with directive: `{directive}`"))
+
+    # Get the terms involved in the relationship
+    from_term_name = process_simple_attribute(txt, ['From Term', 'From Term Name'], ERROR)
+    to_term_name = process_simple_attribute(txt, ['To Term', 'To Term Name'], ERROR)
+    relationship_type = process_simple_attribute(txt, ['Relationship Type'], ERROR)
+
+    if from_term_name is None or to_term_name is None or relationship_type is None:
+        print_msg(ERROR, "Missing required attributes for term-term relationship", debug_level)
+        return None
+
+    # Validate the relationship type
+    if relationship_type not in TERM_RELATIONSHPS:
+        print_msg(ERROR, f"Invalid relationship type: {relationship_type}", debug_level)
+        print_msg(INFO, f"Valid relationship types: {', '.join(TERM_RELATIONSHPS)}", debug_level)
+        return None
+
+    # Get the term GUIDs
+    from_term_q_name, from_term_guid, from_term_valid, from_term_exists = process_element_identifiers(
+        egeria_client, "Term", TERM_NAME_LABELS, txt, EXISTS_REQUIRED, None)
+    to_term_q_name, to_term_guid, to_term_valid, to_term_exists = process_element_identifiers(
+        egeria_client, "Term", TERM_NAME_LABELS, txt, EXISTS_REQUIRED, None)
+
+    if not from_term_exists or not to_term_exists:
+        print_msg(ERROR, "One or both terms do not exist", debug_level)
+        return None
+
+    relationship_display = (f"\n* Command: {command}\n\t* From Term: {from_term_name}\n\t"
+                           f"* To Term: {to_term_name}\n\t* Relationship Type: {relationship_type}\n")
+
+    if directive == "display":
+        print(Markdown(relationship_display))
+        return None
+    elif directive == "validate":
+        print(Markdown(relationship_display))
+        return True
+    elif directive == "process":
+        print(Markdown(relationship_display))
+        try:
+            # Check if the relationship already exists
+            term_relationships = egeria_client.get_term_relationships(from_term_guid)
+            for rel in term_relationships:
+                if rel.get('end2', {}).get('guid', '') == to_term_guid and rel.get('type', {}).get('name', '') == relationship_type:
+                    print_msg(WARNING, f"Relationship already exists between {from_term_name} and {to_term_name}", debug_level)
+                    return None
+
+            # Create the relationship
+            result = egeria_client.create_term_relationship(from_term_guid, to_term_guid, relationship_type)
+            if result:
+                print_msg(ALWAYS, f"Created relationship between {from_term_name} and {to_term_name}", debug_level)
+                return egeria_client.get_term_by_guid(from_term_guid, output_format='MD')
+            else:
+                print_msg(ERROR, f"Failed to create relationship between {from_term_name} and {to_term_name}", debug_level)
+                return None
+        except Exception as e:
+            print_msg(ERROR, f"Error creating term relationship: {e}", debug_level)
+            Console().print_exception(show_locals=True)
+            return None
+
+
+def process_term_list_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+    """
+    Processes a term list command by extracting key attributes such as
+    glossary name, output format, and search string from the given text.
+
+    :param txt: A string representing the input cell to be processed for
+        extracting term-related attributes.
+    :param directive: an optional string indicating the directive to be used - display, validate or execute
+    :return: A string summarizing the outcome of the processing.
+    """
+    from pyegeria.md_processing.utils.common_utils import set_debug_level
+
+    command = extract_command(txt)
+    set_debug_level(directive)
+    print(Markdown(f"{pre_command} `{command}` with directive: `{directive}`"))
+
+    glossary_name = process_simple_attribute(txt, GLOSSARY_NAME_LABELS)
+    category_name = process_simple_attribute(txt, CATEGORY_NAME_LABELS)
+    output_format = process_simple_attribute(txt, OUTPUT_LABELS)
+    output_format = output_format.upper() if output_format else "MD"
+    if output_format not in ELEMENT_OUTPUT_FORMATS:
+        print_msg(WARNING, f"Output format {output_format} not recognized, using MD", debug_level)
+        output_format = "MD"
+
+    search_string = process_simple_attribute(txt, SEARCH_LABELS)
+
+    known_glossary_guid = None
+    known_category_guid = None
+
+    if glossary_name:
+        known_glossary_q_name, known_glossary_guid, glossary_valid, glossary_exists = process_element_identifiers(
+            egeria_client, "Glossary", GLOSSARY_NAME_LABELS, txt, EXISTS_REQUIRED, None)
+        if not glossary_exists:
+            print_msg(ERROR, f"Glossary {glossary_name} not found", debug_level)
+            return None
+
+    if category_name:
+        known_category_q_name, known_category_guid, category_valid, category_exists = process_element_identifiers(
+            egeria_client, "Category", CATEGORY_NAME_LABELS, txt, EXISTS_REQUIRED, None)
+        if not category_exists:
+            print_msg(ERROR, f"Category {category_name} not found", debug_level)
+            return None
+
+    if directive == "display":
+        print(Markdown(f"\n* Command: {command}\n\t* Glossary Name: {glossary_name}\n\t* Category Name: {category_name}\n\t* Output Format: {output_format}\n\t* Search String: {search_string}"))
+        return None
+    elif directive == "validate":
+        print(Markdown(f"\n* Command: {command}\n\t* Glossary Name: {glossary_name}\n\t* Category Name: {category_name}\n\t* Output Format: {output_format}\n\t* Search String: {search_string}"))
+        return True
+    elif directive == "process":
+        print(Markdown(f"\n* Command: {command}\n\t* Glossary Name: {glossary_name}\n\t* Category Name: {category_name}\n\t* Output Format: {output_format}\n\t* Search String: {search_string}"))
+        if category_name and category_exists:
+            return egeria_client.list_terms_for_category(known_category_guid, output_format=output_format, search_string=search_string)
+        elif glossary_name and glossary_exists:
+            return egeria_client.list_terms_for_glossary(known_glossary_guid, output_format=output_format, search_string=search_string)
+        else:
+            return egeria_client.list_terms(output_format=output_format, search_string=search_string)
+
+
+def process_term_details_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+    """
+    Processes a term details command by extracting key attributes such as
+    term name and output format from the given text.
+
+    :param txt: A string representing the input cell to be processed for
+        extracting term-related attributes.
+    :param directive: an optional string indicating the directive to be used - display, validate or execute
+    :return: A string summarizing the outcome of the processing.
+    """
+    from pyegeria.md_processing.utils.common_utils import set_debug_level
+
+    command = extract_command(txt)
+    set_debug_level(directive)
+    print(Markdown(f"{pre_command} `{command}` with directive: `{directive}`"))
+
+    term_name = process_simple_attribute(txt, TERM_NAME_LABELS, ERROR)
+    output_format = process_simple_attribute(txt, OUTPUT_LABELS)
+    output_format = output_format.upper() if output_format else "MD"
+    if output_format not in ELEMENT_OUTPUT_FORMATS:
+        print_msg(WARNING, f"Output format {output_format} not recognized, using MD", debug_level)
+        output_format = "MD"
+
+    if term_name is None:
+        print_msg(ERROR, "No term name found", debug_level)
+        return None
+
+    known_q_name, known_guid, valid, term_exists = process_element_identifiers(egeria_client, "Term",
+                                                                              TERM_NAME_LABELS, txt,
+                                                                              EXISTS_REQUIRED, None)
+    if not term_exists:
+        print_msg(ERROR, f"Term {term_name} not found", debug_level)
+        return None
+
+    if directive == "display":
+        print(Markdown(f"\n* Command: {command}\n\t* Term Name: {term_name}\n\t* Output Format: {output_format}"))
+        return None
+    elif directive == "validate":
+        print(Markdown(f"\n* Command: {command}\n\t* Term Name: {term_name}\n\t* Output Format: {output_format}"))
+        return True
+    elif directive == "process":
+        print(Markdown(f"\n* Command: {command}\n\t* Term Name: {term_name}\n\t* Output Format: {output_format}"))
+        return egeria_client.get_term_by_guid(known_guid, output_format=output_format)
+
+
+def process_term_history_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+    """
+    Processes a term history command by extracting key attributes such as
+    term name and output format from the given text.
+
+    :param txt: A string representing the input cell to be processed for
+        extracting term-related attributes.
+    :param directive: an optional string indicating the directive to be used - display, validate or execute
+    :return: A string summarizing the outcome of the processing.
+    """
+    from pyegeria.md_processing.utils.common_utils import set_debug_level
+
+    command = extract_command(txt)
+    set_debug_level(directive)
+    print(Markdown(f"{pre_command} `{command}` with directive: `{directive}`"))
+
+    term_name = process_simple_attribute(txt, TERM_NAME_LABELS, ERROR)
+    output_format = process_simple_attribute(txt, OUTPUT_LABELS)
+    output_format = output_format.upper() if output_format else "MD"
+    if output_format not in ELEMENT_OUTPUT_FORMATS:
+        print_msg(WARNING, f"Output format {output_format} not recognized, using MD", debug_level)
+        output_format = "MD"
+
+    if term_name is None:
+        print_msg(ERROR, "No term name found", debug_level)
+        return None
+
+    known_q_name, known_guid, valid, term_exists = process_element_identifiers(egeria_client, "Term",
+                                                                              TERM_NAME_LABELS, txt,
+                                                                              EXISTS_REQUIRED, None)
+    if not term_exists:
+        print_msg(ERROR, f"Term {term_name} not found", debug_level)
+        return None
+
+    if directive == "display":
+        print(Markdown(f"\n* Command: {command}\n\t* Term Name: {term_name}\n\t* Output Format: {output_format}"))
+        return None
+    elif directive == "validate":
+        print(Markdown(f"\n* Command: {command}\n\t* Term Name: {term_name}\n\t* Output Format: {output_format}"))
+        return True
+    elif directive == "process":
+        print(Markdown(f"\n* Command: {command}\n\t* Term Name: {term_name}\n\t* Output Format: {output_format}"))
+        return egeria_client.get_term_history(known_guid, output_format=output_format)
+
+
+def process_term_revision_history_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
+    """
+    Processes a term revision history command by extracting key attributes such as
+    term name and output format from the given text.
+
+    :param txt: A string representing the input cell to be processed for
+        extracting term-related attributes.
+    :param directive: an optional string indicating the directive to be used - display, validate or execute
+    :return: A string summarizing the outcome of the processing.
+    """
+    from pyegeria.md_processing.utils.common_utils import set_debug_level
+
+    command = extract_command(txt)
+    set_debug_level(directive)
+    print(Markdown(f"{pre_command} `{command}` with directive: `{directive}`"))
+
+    term_name = process_simple_attribute(txt, TERM_NAME_LABELS, ERROR)
+    output_format = process_simple_attribute(txt, OUTPUT_LABELS)
+    output_format = output_format.upper() if output_format else "MD"
+    if output_format not in ELEMENT_OUTPUT_FORMATS:
+        print_msg(WARNING, f"Output format {output_format} not recognized, using MD", debug_level)
+        output_format = "MD"
+
+    if term_name is None:
+        print_msg(ERROR, "No term name found", debug_level)
+        return None
+
+    known_q_name, known_guid, valid, term_exists = process_element_identifiers(egeria_client, "Term",
+                                                                              TERM_NAME_LABELS, txt,
+                                                                              EXISTS_REQUIRED, None)
+    if not term_exists:
+        print_msg(ERROR, f"Term {term_name} not found", debug_level)
+        return None
+
+    if directive == "display":
+        print(Markdown(f"\n* Command: {command}\n\t* Term Name: {term_name}\n\t* Output Format: {output_format}"))
+        return None
+    elif directive == "validate":
+        print(Markdown(f"\n* Command: {command}\n\t* Term Name: {term_name}\n\t* Output Format: {output_format}"))
+        return True
+    elif directive == "process":
+        print(Markdown(f"\n* Command: {command}\n\t* Term Name: {term_name}\n\t* Output Format: {output_format}"))
+        return egeria_client.get_term_revision_history(known_guid, output_format=output_format)

pyegeria/md_processing/utils/__init__.py

@@ -0,0 +1,3 @@
+"""
+This package contains utility functions for processing Egeria Markdown
+"""

pyegeria/md_processing/utils/common_utils.py

@@ -0,0 +1,101 @@
+"""
+This file contains general utility functions for processing Egeria Markdown
+"""
+import os
+import re
+from datetime import datetime
+from typing import List, Optional, Any
+
+from rich import print
+from rich.console import Console
+from rich.markdown import Markdown
+
+from pyegeria._globals import DEBUG_LEVEL
+
+# Constants
+EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "170"))
+console = Console(width=EGERIA_WIDTH)
+
+message_types = {
+    "INFO": "INFO-", "WARNING": "WARNING->", "ERROR": "ERROR->", "DEBUG-INFO": "DEBUG-INFO->",
+    "DEBUG-WARNING": "DEBUG-WARNING->", "DEBUG-ERROR": "DEBUG-ERROR->", "ALWAYS": "\n\n==> "
+}
+ALWAYS = "ALWAYS"
+ERROR = "ERROR"
+INFO = "INFO"
+WARNING = "WARNING"
+pre_command = "\n---\n==> Processing command:"
+command_seperator = Markdown("\n---\n")
+EXISTS_REQUIRED = "Exists Required"
+
+debug_level = DEBUG_LEVEL
+
+def render_markdown(markdown_text: str) -> None:
+    """Renders the given markdown text in the console."""
+    console.print(Markdown(markdown_text))
+
+
+def is_valid_iso_date(date_text) -> bool:
+    """Checks if the given string is a valid ISO date."""
+    try:
+        datetime.strptime(date_text, '%Y-%m-%d')
+        return True
+    except ValueError:
+        return False
+
+
+def set_debug_level(directive: str) -> None:
+    """Sets the debug level for the script."""
+    global debug_level
+    if directive == "display":
+        debug_level = "display-only"
+
+
+def get_current_datetime_string():
+    """Returns the current date and time as a human-readable string."""
+    now = datetime.now().strftime('%Y-%m-%d %H:%M')
+    return now
+
+
+def print_msg(msg_level: str, msg: str, verbosity: str):
+    """
+    Prints a message based on its type and verbosity level.
+
+    This function handles the output of messages depending on the specified
+    verbosity level and message type. It uses predefined message types and
+    formats the output accordingly.
+
+    Args:
+        msg_type: The type of the message, such as 'WARNING', 'ERROR', 'INFO', or
+            'ALWAYS'.
+        msg: The content of the message to display.
+        verbosity: The verbosity level, which determines how the message is
+            displayed ('verbose', 'quiet', or 'debug').
+    """
+    if msg_level == "ALWAYS":
+        print(f"{message_types.get(msg_level, '')}{msg}")
+    elif verbosity == "verbose" and msg_level in ["INFO", "WARNING", "ERROR"]:
+        print(f"{message_types.get(msg_level, '')}{msg}")
+    elif verbosity == "quiet" and msg_level in ["WARNING", "ERROR"]:
+        print(f"{message_types.get(msg_level, '')}{msg}")
+    elif verbosity == "debug" and msg_level in ["INFO", "WARNING", "ERROR", "DEBUG-INFO", "DEBUG-WARNING", "DEBUG-ERROR"]:
+        print(f"{message_types.get(msg_level, '')}{msg}")
+    elif verbosity == "display-only" and msg_level in ["ALWAYS", "ERROR"]:
+        print(f"{message_types.get(msg_level, '')}{msg}")
+
+
+def process_provenance_command(file_path: str, txt: [str]) -> str:
+    """
+    Processes a provenance command by extracting the file path and current datetime.
+
+    Args:
+        file_path: The path to the file being processed.
+        txt: The text containing the provenance command.
+
+    Returns:
+        A string containing the provenance information.
+    """
+    now = get_current_datetime_string()
+    file_name = os.path.basename(file_path)
+    provenance = f"\n\n\n# Provenance:\n \n* Derived from processing file {file_name} on {now}\n"
+    return provenance