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

pyegeria/md_processing/commands/glossary_commands.py

@@ -1,225 +0,0 @@
-"""
-This file contains glossary-related command functions for processing Egeria Markdown
-"""
-from typing import Optional
-
-from rich.markdown import Markdown
-
-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
-)
-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
-)
-from pyegeria.dr_egeria_state import update_element_dictionary
-
-def process_glossary_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
-    """
-    Processes a glossary create or update command by extracting key attributes such as
-    glossary name, language, description, and usage from the given text.
-
-    :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.
-    """
-
-    command, object_type, object_action = extract_command_plus(txt)
-    from pyegeria.md_processing.utils.common_utils import set_debug_level
-    set_debug_level(directive)
-
-    glossary_name = process_simple_attribute(txt, GLOSSARY_NAME_LABELS, ERROR)
-    print(Markdown(
-        f"{pre_command} `{object_action}` `{object_type}`  for glossary: `\'{glossary_name}\'` with directive: `"
-        f"{directive}` "))
-    language = process_simple_attribute(txt, ['Language'], INFO)
-    description = process_simple_attribute(txt, ['Description'], INFO)
-    usage = process_simple_attribute(txt, ['Usage'], INFO)
-    q_name = process_simple_attribute(txt, ['Qualified Name'], INFO)
-    valid = True
-
-    if glossary_name is None:
-        valid = False
-        known_q_name = None
-        known_guid = None
-        glossary_exists = False
-    else:
-        element_labels = GLOSSARY_NAME_LABELS
-        element_labels.append('Display Name')
-        known_q_name, known_guid, valid, glossary_exists = process_element_identifiers(egeria_client, object_type,
-                                                                                       element_labels, txt,
-                                                                                       object_action, None)
-    glossary_display = (f"\n* Command: `{command}`\n\t* Glossary Name: {glossary_name}\n\t"
-                        f"* Language: {language}\n\t* Description:\n{description}\n"
-                        f"* Usage: {usage}\n")
-
-    if object_action == 'Update':
-        guid = process_simple_attribute(txt, ['GUID', 'guid', 'Guid'])
-        glossary_display += f"* Qualified Name: `{q_name}`\n\t* GUID: {guid}\n\n"
-        if not glossary_exists:
-            msg = f"Glossary can't be updated; `{glossary_name}` not found"
-            print_msg("ERROR", msg, debug_level)
-            valid = False
-        else:
-            msg = f"Glossary can be updated; `{glossary_name}` found"
-            print_msg(ALWAYS, msg, debug_level)
-
-
-    elif object_action == "Create":
-        if glossary_exists:
-            msg = f"Glossary `{glossary_name}` can't be created because it already exists.\n"
-            print_msg("ERROR", msg, debug_level)
-            valid = False
-        elif valid:
-            msg = f"It is valid to create Glossary `{glossary_name}` with:\n"
-            print_msg("ALWAYS", msg, debug_level)
-
-    if directive == "display":
-        print(Markdown(glossary_display))
-        return None
-
-    elif directive == "validate":
-        if valid:
-            print(Markdown(glossary_display))
-        else:
-            msg = f"Validation failed for Glossary `{glossary_name}`\n"
-            print_msg(ERROR, msg, debug_level)
-            print(Markdown(glossary_display))
-
-        return valid
-
-    elif directive == "process":
-        if valid:
-            print(Markdown(glossary_display))
-        else:
-            if glossary_exists and object_action == "Create":
-                msg = f"Create failed because glossary `{glossary_name}` exists - changing `Create` to `Update` in processed output \n"
-                print_msg(ERROR, msg, debug_level)
-                print(Markdown(glossary_display))
-                return update_a_command(txt, command, object_type, known_q_name, known_guid)
-            else:
-                return None
-        if object_action == "Update":
-            if not glossary_exists:
-                print(f"\n{ERROR}Glossary `{glossary_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": "GlossaryProperties", "qualifiedName": known_q_name, "description": description,
-                    "language": language, "usage": usage
-                    }
-                }
-            egeria_client.update_glossary(known_guid, body)
-            print_msg(ALWAYS, f"Updated Glossary `{glossary_name}` with GUID {known_guid}", debug_level)
-            update_element_dictionary(known_q_name, {
-                'guid': known_guid, 'display_name': glossary_name
-                })
-            return egeria_client.get_glossary_by_guid(known_guid, output_format='MD')
-        elif object_action == "Create":
-            glossary_guid = None
-
-            if glossary_exists:
-                print(f"\nGlossary `{glossary_name}` already exists and result document updated\n")
-                return update_a_command(txt, command, object_type, known_q_name, known_guid)
-            else:
-                glossary_guid = egeria_client.create_glossary(glossary_name, description, language, usage)
-                if glossary_guid:
-                    print_msg(ALWAYS, f"Created Glossary `{glossary_name}` with GUID {glossary_guid}", debug_level)
-                    return egeria_client.get_glossary_by_guid(glossary_guid, output_format='MD')
-                else:
-                    print_msg(ERROR, f"Failed to create Glossary `{glossary_name}`", debug_level)
-                    return None
-        else:
-            return None
-    else:
-        return None
-
-def process_glossary_list_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
-    """
-    Processes a glossary list command by extracting key attributes such as
-    output format and search string from the given text.
-
-    :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
-    from pyegeria.md_processing.utils.display_utils import OUTPUT_LABELS, SEARCH_LABELS, ELEMENT_OUTPUT_FORMATS
-
-    command = extract_command(txt)
-    set_debug_level(directive)
-    print(Markdown(f"{pre_command} `{command}` with directive: `{directive}`"))
-
-    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)
-
-    if directive == "display":
-        print(Markdown(f"\n* Command: {command}\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* Output Format: {output_format}\n\t* Search String: {search_string}"))
-        return True
-    elif directive == "process":
-        print(Markdown(f"\n* Command: {command}\n\t* Output Format: {output_format}\n\t* Search String: {search_string}"))
-        return egeria_client.list_glossaries(output_format=output_format, search_string=search_string)
-
-
-def process_glossary_structure_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") -> Optional[str]:
-    """
-    Processes a glossary structure command by extracting key attributes such as
-    glossary name and output format from the given text.
-
-    :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
-    from pyegeria.md_processing.utils.display_utils import OUTPUT_LABELS, ELEMENT_OUTPUT_FORMATS
-
-    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, 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 glossary_name is None:
-        print_msg(ERROR, "No glossary name found", debug_level)
-        return None
-
-    known_q_name, known_guid, 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 directive == "display":
-        print(Markdown(f"\n* Command: {command}\n\t* Glossary Name: {glossary_name}\n\t* Output Format: {output_format}"))
-        return None
-    elif directive == "validate":
-        print(Markdown(f"\n* Command: {command}\n\t* Glossary Name: {glossary_name}\n\t* Output Format: {output_format}"))
-        return True
-    elif directive == "process":
-        print(Markdown(f"\n* Command: {command}\n\t* Glossary Name: {glossary_name}\n\t* Output Format: {output_format}"))
-        return egeria_client.get_glossary_structure(known_guid, output_format=output_format)

pyegeria/md_processing/commands/project_commands.py

@@ -1,169 +0,0 @@
-"""
-This file contains project-related command functions for processing Egeria Markdown
-"""
-from typing import Optional, Tuple
-
-from rich.markdown import Markdown
-
-from pyegeria.project_manager_omvs import ProjectManager
-from pyegeria.md_processing.utils.common_utils import (
-    debug_level, print_msg, ALWAYS, ERROR, INFO, WARNING, pre_command, command_seperator, is_valid_iso_date
-)
-from pyegeria.md_processing.utils.extraction_utils import (
-    extract_command, process_simple_attribute
-)
-from pyegeria.md_processing.utils.display_utils import (
-    PROJECT_NAME_LABELS
-)
-from pyegeria._globals import NO_PROJECTS_FOUND
-
-def process_per_proj_upsert_command(egeria_client: ProjectManager, txt: str, directive: str = "display") -> str | None:
-    """
-    Processes a personal project create or update command by extracting key attributes such as
-    glossary name, language, description, and usage 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
-    
-    command = extract_command(txt)
-    object = command.split()
-    object_type = f"{object[1]} {object[2]}"
-    object_action = object[0]
-    set_debug_level(directive)
-
-    project_name = process_simple_attribute(txt, ['Project Name'])
-    description = process_simple_attribute(txt, ['Description'])
-    project_identifier = process_simple_attribute(txt, ['Project Identifier'])
-    project_status = process_simple_attribute(txt, ['Project Status'])
-    project_phase = process_simple_attribute(txt, ['Project Phase'])
-    project_health = process_simple_attribute(txt, ['Project Health'])
-    start_date = process_simple_attribute(txt, ['Start Date'])
-    planned_end_date = process_simple_attribute(txt, ['Planned End Date'])
-    print(Markdown(f"{pre_command} `\'{command}\'` for project: `{project_name}` with directive: `{directive}` "))
-
-    project_display = (f"\n* Command: {command}\n\t* Project: {project_name}\n\t"
-                       f"* Status: {project_status}\n\t* Description: {description}\n\t"
-                       f"* Phase: {project_phase}\n\t* Health: {project_health}\n\t"
-                       f"* Start Date: {start_date}\n\t* Planned End Date: {planned_end_date}\n")
-
-    def validate_project(obj_action: str) -> tuple[bool, bool, str, str]:
-        valid = True
-        msg = ""
-        known_guid = None
-        known_q_name = None
-
-        project_details = egeria_client.get_projects_by_name(project_name)
-        if project_details == NO_PROJECTS_FOUND:
-            project_exists = False
-        else:
-            project_exists = True
-
-        if project_name is None:
-            msg = f"* {ERROR}Project name is missing\n"
-            valid = False
-        if project_status is None:
-            msg += f"* {INFO}No Project status found\n"
-
-        if description is None:
-            msg += f"* {INFO}No Description found\n"
-
-        if project_identifier is None:
-            msg += f"* {INFO}No Project Identifier found\n"
-
-        if project_phase is None:
-            msg += f"* {INFO}No Project Phase found\n"
-
-        if project_health is None:
-            msg += f"* {INFO}No Project Health found\n"
-
-        if start_date is None:
-            msg += f"* {INFO}No Start Date found\n"
-        elif not is_valid_iso_date(start_date):
-            msg += f"* {ERROR}Start Date is not a valid ISO date of form  YYYY-MM-DD\n"
-            valid = False
-
-        if planned_end_date is None:
-            msg += f"* {INFO} No Planned End Date found\n"
-        elif not is_valid_iso_date(planned_end_date):
-            msg += f"* {ERROR}Planned End Date is not a valid ISO date of form  YYYY-MM-DD\n"
-            valid = False
-
-        if obj_action == "Update":
-            q_name = process_simple_attribute(txt, 'Qualified Name')
-
-            if not project_exists:
-                msg += f"* {ERROR}Project {project_name} does not exist\n"
-                valid = False
-            if len(project_details) > 1 and project_exists:
-                msg += f"* {ERROR}More than one project with name {project_name} found\n"
-                valid = False
-            if len(project_details) == 1:
-                known_guid = project_details[0]['elementHeader'].get('guid', None)
-                known_q_name = project_details[0]['glossaryProperties'].get('qualifiedName', None)
-            if q_name is None:
-                msg += f"* {INFO}Qualified Name is missing => can use known qualified name of {known_q_name}\n"
-                valid = True
-            elif q_name != known_q_name:
-                msg += (f"* {ERROR}Project {project_name} qualifiedName mismatch between {q_name} and {known_q_name}\n")
-                valid = False
-            if valid:
-                msg += project_display
-                msg += f"* -->Project {project_name} exists and can be updated\n"
-            else:
-                msg += f"* --> validation failed\n"
-            msg += '---'
-            print(Markdown(msg))
-            return valid, project_exists, known_guid, known_q_name
-
-        elif obj_action == "Create":
-            if project_exists:
-                msg += f"\n{ERROR}Project {project_name} already exists"
-            else:
-                msg += f"\n-->It is valid to create Project \'{project_name}\' with:\n"
-            print(Markdown(msg))
-            return valid, project_exists, known_guid, known_q_name
-
-    if directive == "display":
-        print(Markdown(project_display))
-        return None
-    elif directive == "validate":
-        valid, project_exists, known_guid, known_q_name = validate_project(object_action)
-        return valid
-    elif directive == "process":
-        valid, project_exists, known_guid, known_q_name = validate_project(object_action)
-        if valid:
-            if object_action == "Create":
-                if project_exists:
-                    print(f"\n{ERROR}Project {project_name} already exists\n")
-                    return None
-                else:
-                    project_guid = egeria_client.create_personal_project(project_name, description, project_identifier,
-                                                                        project_status, project_phase, project_health,
-                                                                        start_date, planned_end_date)
-                    if project_guid:
-                        print_msg(ALWAYS, f"Created Project {project_name} with GUID {project_guid}", debug_level)
-                        return egeria_client.get_project_by_guid(project_guid, output_format='MD')
-                    else:
-                        print_msg(ERROR, f"Failed to create Project {project_name}", debug_level)
-                        return None
-            elif object_action == "Update":
-                if not project_exists:
-                    print(f"\n{ERROR}Project {project_name} does not exist\n")
-                    return None
-                else:
-                    project_guid = egeria_client.update_personal_project(known_guid, project_name, description,
-                                                                        project_identifier, project_status,
-                                                                        project_phase, project_health, start_date,
-                                                                        planned_end_date)
-                    if project_guid:
-                        print_msg(ALWAYS, f"Updated Project {project_name} with GUID {project_guid}", debug_level)
-                        return egeria_client.get_project_by_guid(project_guid, output_format='MD')
-                    else:
-                        print_msg(ERROR, f"Failed to update Project {project_name}", debug_level)
-                        return None
-        else:
-            return None