pyegeria 5.4.0.dev13__py3-none-any.whl → 5.4.0.dev14__py3-none-any.whl

md_processing/md_commands/project_commands.py

@@ -4,12 +4,13 @@ This file contains project-related object_action functions for processing Egeria
 
 from rich.markdown import Markdown
 
-from md_processing.md_processing_utils.common_md_utils import (debug_level, print_msg, is_valid_iso_date)
+from md_processing.md_processing_utils.common_md_utils import (debug_level, print_msg, is_valid_iso_date, setup_log)
 from md_processing.md_processing_utils.extraction_utils import (extract_command, process_simple_attribute)
 from md_processing.md_processing_utils.md_processing_constants import ALWAYS, ERROR, INFO, pre_command
 from pyegeria._globals import NO_PROJECTS_FOUND
 from pyegeria.project_manager_omvs import ProjectManager
 
+setup_log()
 
 def process_per_proj_upsert_command(egeria_client: ProjectManager, txt: str, directive: str = "display") -> str | None:
     """
@@ -24,6 +25,8 @@ def process_per_proj_upsert_command(egeria_client: ProjectManager, txt: str, dir
     from md_processing.md_processing_utils.common_md_utils import set_debug_level
 
     command = extract_command(txt)
+    print(Markdown(f"# {command}\n"))
+
     object = command.split()
     object_type = f"{object[1]} {object[2]}"
     object_action = object[0]
@@ -32,7 +35,7 @@ def process_per_proj_upsert_command(egeria_client: ProjectManager, txt: str, dir
     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_status = process_simple_attribute(txt, ['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'])

md_processing/md_commands/solution_architect_commands.py

@@ -12,7 +12,7 @@ from rich.console import Console
 from rich.markdown import Markdown
 
 from md_processing.md_processing_utils.common_md_proc_utils import (parse_upsert_command, parse_view_command)
-from md_processing.md_processing_utils.common_md_utils import update_element_dictionary
+from md_processing.md_processing_utils.common_md_utils import update_element_dictionary, setup_log
 from md_processing.md_processing_utils.extraction_utils import (extract_command_plus, update_a_command)
 from md_processing.md_processing_utils.md_processing_constants import (load_commands)
 from pyegeria import body_slimmer, EgeriaTech
@@ -20,12 +20,8 @@ from pyegeria import body_slimmer, EgeriaTech
 load_commands('commands.json')
 
 console = Console(width=int(200))
+setup_log()
 
-log_format = "D {time} | {level} | {function} | {line} | {message} | {extra}"
-logger.remove()
-logger.add(sys.stderr, level="INFO", format=log_format, colorize=True)
-logger.add("solution_architect_log.log", rotation="1 day", retention="1 week", compression="zip", level="TRACE",
-           format=log_format, colorize=True)
 
 @logger.catch
 def sync_chain_related_elements(egeria_client: EgeriaTech, guid:str, in_supply_chain_guids:list, display_name:str,
@@ -264,7 +260,7 @@ def process_blueprint_upsert_command(egeria_client: EgeriaTech, txt: str, direct
     :return: A string summarizing the outcome of the processing.
     """
     command, object_type, object_action = extract_command_plus(txt)
-
+    print(Markdown(f"# {command}\n"))
     parsed_output = parse_upsert_command(egeria_client, object_type, object_action, txt, directive)
 
     valid = parsed_output['valid']
@@ -432,6 +428,7 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, txt: st
     :return: A string summarizing the outcome of the processing.
     """
     command, object_type, object_action = extract_command_plus(txt)
+    print(Markdown(f"# {command}\n"))
 
     parsed_output = parse_upsert_command(egeria_client, object_type, object_action, txt, directive)
 
@@ -452,7 +449,7 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, txt: st
     version_identifier = attributes.get('Version Identifier', {}).get('value', None)
     solution_component_type = attributes.get('Solution Component Type', {}).get('value', None)
     planned_deployed_impl_type = attributes.get('Planned Deployed Implementation Type', {}).get('value', None)
-    initial_status = attributes.get('Initial Status', {}).get('value', None)
+    initial_status = attributes.get('Status', {}).get('value', None)
     user_defined_status = attributes.get('User Defined Status', {}).get('value', None)
     if initial_status != "OTHER":
         user_defined_status = None
@@ -656,6 +653,7 @@ def process_component_link_unlink_command(egeria_client: EgeriaTech, txt: str,
     :return: A string summarizing the outcome of the processing.
     """
     command, object_type, object_action = extract_command_plus(txt)
+    print(Markdown(f"# {command}\n"))
 
     parsed_output = parse_view_command(egeria_client, object_type, object_action, txt, directive)
 
@@ -782,6 +780,7 @@ def process_information_supply_chain_upsert_command(egeria_client: EgeriaTech, t
     :return: A string summarizing the outcome of the processing.
     """
     command, object_type, object_action = extract_command_plus(txt)
+    print(Markdown(f"# {command}\n"))
 
     parsed_output = parse_upsert_command(egeria_client, object_type, object_action, txt, directive)
 
@@ -956,6 +955,7 @@ def process_information_supply_chain_link_unlink_command(egeria_client: EgeriaTe
     :return: A string summarizing the outcome of the processing.
     """
     command, object_type, object_action = extract_command_plus(txt)
+    print(Markdown(f"# {command}\n"))
 
     parsed_output = parse_view_command(egeria_client, object_type, object_action, txt, directive)
 
@@ -1078,6 +1078,7 @@ def process_sol_arch_list_command(egeria_client: EgeriaTech, txt: str, kind:str,
     :return: A string summarizing the outcome of the processing.
     """
     command, object_type, object_action = extract_command_plus(txt)
+    print(Markdown(f"# {command}\n"))
 
     parsed_output = parse_view_command(egeria_client, object_type, object_action, txt, directive)
 

md_processing/md_processing_utils/common_md_proc_utils.py

@@ -163,7 +163,7 @@ def parse_upsert_command(egeria_client: EgeriaTech, object_type: str, object_act
             elif style == 'Ordered Int':
                 parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing)
             elif style == 'Simple Int':
-                parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value)
+                parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value, "int")
             elif style == 'Simple List':
                 parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value)
                 name_list = parsed_attributes[key]['value']
@@ -187,7 +187,7 @@ def parse_upsert_command(egeria_client: EgeriaTech, object_type: str, object_act
                     parsed_output['valid'] = False
                     parsed_output['reason'] += msg
             else:
-                msg = f"Unknown attribute style: {style}"
+                msg = f"Unknown attribute style: {style} for key `{key}`"
                 logger.error(msg)
                 sys.exit(1)
                 parsed_attributes[key]['valid'] = False
@@ -264,7 +264,7 @@ def parse_view_command(egeria_client: EgeriaTech, object_type: str, object_actio
     parsed_output['exists'] = False
 
     labels = {}
-    if object_action == "Unlink":
+    if object_action in ["Unlink","Detach"]:
         command_spec = get_command_spec(f"Link {object_type}")
     else:
         command_spec = get_command_spec(f"{object_action} {object_type}")
@@ -362,7 +362,7 @@ def parse_view_command(egeria_client: EgeriaTech, object_type: str, object_actio
             elif style == 'Ordered Int':
                 parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing)
             elif style == 'Simple Int':
-                parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value)
+                parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value, "int")
             elif style == 'Simple List':
                 parsed_attributes[key] = proc_simple_attribute(txt, object_action, labels, if_missing, default_value)
                 name_list = parsed_attributes[key]['value']
@@ -410,7 +410,8 @@ def parse_view_command(egeria_client: EgeriaTech, object_type: str, object_actio
 
 
 @logger.catch
-def proc_simple_attribute(txt: str, action: str, labels: set, if_missing: str = INFO, default_value=None) -> dict:
+def proc_simple_attribute(txt: str, action: str, labels: set, if_missing: str = INFO, default_value=None,
+                          simp_type: str = None) -> dict:
     """Process a simple attribute based on the provided labels and if_missing value.
        Extract the attribute value from the text and store it in a dictionary along with valid.
        If it doesn`t exist, mark the dictionary entry as invalid and print an error message with severity of if_missing.
@@ -433,14 +434,14 @@ def proc_simple_attribute(txt: str, action: str, labels: set, if_missing: str =
         logger.error(msg)
         return {"status": ERROR, "reason": msg, "value": None, "valid": False}
 
-    attribute = extract_attribute(txt, labels)
-
     if default_value == "":
         default_value = None
-    attribute = default_value if attribute is None else attribute.replace('\n','')
 
-    if attribute is None:
+    attribute = extract_attribute(txt, labels)
+
+    attribute = default_value if attribute is None else attribute.replace('\n', '')
 
+    if attribute is None:
         if if_missing == INFO or if_missing == WARNING:
             msg = f"Optional attribute with labels: `{labels}` missing"
             valid = True
@@ -450,6 +451,10 @@ def proc_simple_attribute(txt: str, action: str, labels: set, if_missing: str =
             valid = False
             logger.error(msg)
         return {"status": if_missing, "reason": msg, "value": None, "valid": valid, "exists": False}
+
+    if attribute and simp_type == "int" :
+        attribute = int(attribute)
+
     return {"status": INFO, "OK": None, "value": attribute, "valid": valid, "exists": True}
 
 
@@ -637,7 +642,7 @@ def proc_el_id(egeria_client: EgeriaTech, element_type: str, qn_prefix: str, ele
         logger.error(msg)
         identifier_output = {"status": ERROR, "reason": msg, "value": element_name, "valid": False, "exists": False, }
 
-    elif action == "Update" and exists:
+    elif action in ["Update", "View"] and exists:
         msg = f"Element {element_name} exists"
         logger.info(msg)
         identifier_output = {

md_processing/md_processing_utils/common_md_utils.py

@@ -3,23 +3,60 @@ This file contains general utility functions for processing Egeria Markdown
 """
 import os
 import re
+import sys
+import json
 from datetime import datetime
 from typing import Any
 from loguru import logger
 from rich import print
 from rich.console import Console
 from rich.markdown import Markdown
-
+from pyegeria.utils import (camel_to_title_case)
 from pyegeria._globals import DEBUG_LEVEL
 from md_processing.md_processing_utils.message_constants import message_types
 
 # Constants
-EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "170"))
+EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
+EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9092")
+EGERIA_PLATFORM_URL = os.environ.get("EGERIA_PLATFORM_URL", "https://localhost:9443")
+EGERIA_VIEW_SERVER = os.environ.get("EGERIA_VIEW_SERVER", "view-server")
+EGERIA_VIEW_SERVER_URL = os.environ.get("EGERIA_VIEW_SERVER_URL", "https://localhost:9443")
+EGERIA_INTEGRATION_DAEMON = os.environ.get("EGERIA_INTEGRATION_DAEMON", "integration-daemon")
+EGERIA_INTEGRATION_DAEMON_URL = os.environ.get("EGERIA_INTEGRATION_DAEMON_URL", "https://localhost:9443")
+EGERIA_ADMIN_USER = os.environ.get("ADMIN_USER", "garygeeke")
+EGERIA_ADMIN_PASSWORD = os.environ.get("ADMIN_PASSWORD", "secret")
+EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
+EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
+EGERIA_WIDTH = os.environ.get("EGERIA_WIDTH", 220)
+EGERIA_JUPYTER = os.environ.get("EGERIA_JUPYTER", False)
+EGERIA_HOME_GLOSSARY_GUID = os.environ.get("EGERIA_HOME_GLOSSARY_GUID", None)
+EGERIA_GLOSSARY_PATH = os.environ.get("EGERIA_GLOSSARY_PATH", None)
+EGERIA_ROOT_PATH = os.environ.get("EGERIA_ROOT_PATH", "../../")
+EGERIA_INBOX_PATH = os.environ.get("EGERIA_INBOX_PATH", "md_processing/dr_egeria_inbox")
+EGERIA_OUTBOX_PATH = os.environ.get("EGERIA_OUTBOX_PATH", "md_processing/dr_egeria_outbox")
+LOG_FORMAT = "D <green> {time} </green> | {level} | {function} | {line} | {message} | {extra}"
+CONSOLE_LOG_FORMAT = "<green>{time}</green> | {message}"
+
 console = Console(width=EGERIA_WIDTH)
+GENERAL_GOVERNANCE_DEFINITIONS = ["Business Imperative", "Regulation Article", "Threat", "Governance Principle",
+                                  "Governance Obligation", "Governance Approach", "Governance Processing Purpose"]
+
+GOVERNANCE_CONTROLS = ["Governance Rule", "Service Level Objective", "Governance Process",
+                       "Governance Responsibility", "Governance Procedure", "Security Access Control"]
 
 debug_level = DEBUG_LEVEL
 global COMMAND_DEFINITIONS
 
+def setup_log():
+    logger.remove()
+    logger.add(sys.stderr, level="SUCCESS", format=CONSOLE_LOG_FORMAT, colorize=True)
+    full_file_path = os.path.join(EGERIA_ROOT_PATH, EGERIA_INBOX_PATH, "data_designer_debug.log")
+    # logger.add(full_file_path, rotation="1 day", retention="1 week", compression="zip", level="TRACE", format=log_format,
+    #            colorize=True)
+    logger.add("debug_log", rotation="1 day", retention="1 week", compression="zip", level="INFO", format=LOG_FORMAT,
+               colorize=True)
+
+
 def split_tb_string(input: str)-> [Any]:
     """Split the string and trim the items"""
     l = [item.strip() for item in re.split(r'[;,\n]+',input)] if input is not None else None
@@ -177,3 +214,158 @@ def find_key_with_value(value: str) -> str | None:
             return key
 
     return None  # If value not found
+
+
+def set_create_body(object_type: str, attributes: dict)->dict:
+    prop_name = object_type.replace(" ", "")
+    body = {
+        "class": "NewGovernanceDefinitionRequestBody",
+        "externalSourceGUID": attributes.get('External Source GUID', {}).get('guid', None),
+        "externalSourceName": attributes.get('External Source Name', {}).get('value', None),
+        "effectiveTime": attributes.get('Effective Time', {}).get('value', None),
+        "forLineage": attributes.get('For Lineage', {}).get('value', False),
+        "forDuplicateProcessing": attributes.get('For Duplicate Processing', {}).get('value', False),
+        "anchorGUID": attributes.get('Anchor ID', {}).get('guid', None),
+        "isOwnAnchor": attributes.get('Is Own Anchor', {}).get('value', True),
+        "parentGUID": attributes.get('Parent ID', {}).get('guid', None),
+        "parentRelationshipTypeName": attributes.get('Parent Relationship Type Name', {}).get('value', None),
+        "parentRelationshipProperties": attributes.get('Parent Relationship Properties', {}).get('value', None),
+        "parentAtEnd1": attributes.get('Parent at End1', {}).get('value', True),
+        "properties": "",
+        "initialStatus": attributes.get('Status', {}).get('value', "ACTIVE")
+        }
+
+    return body
+
+
+
+
+def set_update_body(object_type: str, attributes: dict)->dict:
+    return {
+      "class" : "UpdateElementRequestBody",
+      "externalSourceGUID": attributes.get('External Source GUID', {}).get('guid', None),
+      "externalSourceName": attributes.get('External Source Name', {}).get('value', None),
+      "effectiveTime": attributes.get('Effective Time', {}).get('value', None),
+      "forLineage": attributes.get('For Lineage', {}).get('value', False),
+      "forDuplicateProcessing": attributes.get('For Duplicate Processing', {}).get('value', False),
+      "mergeUpdate": attributes.get('Merge Update', {}).get('value', True),
+      "properties": "",
+    }
+
+def set_prop_body(object_type: str, qualified_name: str, attributes: dict)->dict:
+
+    prop_name = object_type.replace(" ", "")
+
+    return {
+        "class": prop_name + "Properties",
+        "displayName": attributes['Display Name'].get('value', None),
+        "qualifiedName" : qualified_name,
+        "description": attributes['Description'].get('value', None),
+        "versionIdentifier": attributes.get('Version Identifier', {}).get('value', None),
+        "effectiveFrom": attributes.get('Effective From', {}).get('value', None),
+        "effectiveTo": attributes.get('Effective To', {}).get('value', None),
+        "additionalProperties": attributes.get('Additional Properties', {}).get('value', None),
+        "extendedProperties": attributes.get('Extended Properties', {}).get('value', None)
+        }
+
+def set_gov_prop_body(object_type: str, qualified_name: str, attributes: dict)->dict:
+    prop_name = object_type.replace(" ", "")
+    prop_bod = set_prop_body(object_type, qualified_name, attributes)
+    prop_bod["domainIdentifier"] = attributes.get('Domain Identifier', {}).get('value', None)
+    # prop_bod["documentIdentifier"] =  attributes.get('Document Identifier', {}).get('value', None)
+    prop_bod["title"]= attributes.get('Display Name', {}).get('value', None)
+    prop_bod['documentIdentifier'] = qualified_name
+    prop_bod["versionIdentifier"] = attributes.get('Version Identifier', {}).get('value', None)
+    prop_bod["summary"] = attributes.get('Summary', {}).get('value', None)
+    prop_bod["scope"] = attributes.get('Scope', {}).get('value', None)
+    prop_bod["importance"] = attributes.get('Importance', {}).get('value', None)
+    prop_bod["implications"] = attributes.get('Implication', {}).get('value', [])
+    prop_bod["outcomes"] = attributes.get('Outcomes', {}).get('value', [])
+    prop_bod["results"] = attributes.get('Results', {}).get('value', [])
+
+    body = update_body_for_type(object_type, prop_bod, attributes)
+    return body
+    
+
+def update_body_for_type(object_type: str, body: dict, attributes: dict) -> dict:
+    gov_def_name = object_type.replace(" ", "")
+    if object_type in GENERAL_GOVERNANCE_DEFINITIONS:
+        return body
+    elif object_type == "Governance Strategy":
+        body['businessImperatives'] = attributes.get('Business Imperatives', {}).get('value', [])
+        return body
+
+    elif object_type == "Regulation":
+        body['source'] = attributes.get('Source', {}).get('value', None)
+        body['regulators'] = attributes.get('Regulators', {}).get('value', [])
+        return body
+
+    elif object_type in GOVERNANCE_CONTROLS:
+        body['implementationDescription'] = attributes.get('Implementation Description', {}).get('value', None)
+        return body
+    elif object_type == "Security Group":
+        body['distinguishedName'] = attributes.get('Distinguished Name', {}).get('value', None)
+        return body
+    elif object_type == "Naming Standard Rule":
+        body['namePatterns'] = attributes.get('Name Patterns', {}).get('value', [])
+        return body
+    elif object_type in ["Certification Type", "License Type"]:
+        body['details'] = attributes.get('Details', {}).get('value', None)
+        return body
+
+
+def set_rel_request_body(object_type: str, attributes: dict)->dict:
+    return {
+      "class" : "RelationshipRequestBody",
+      "externalSourceGUID": attributes.get('External Source GUID', {}).get('guid', None),
+      "externalSourceName": attributes.get('External Source Name', {}).get('value', None),
+      "effectiveTime": attributes.get('Effective Time', {}).get('value', None),
+      "forLineage": attributes.get('For Lineage', {}).get('value', False),
+      "forDuplicateProcessing": attributes.get('For Duplicate Processing', {}).get('value', False),
+      "properties": "",
+    }
+
+def set_peer_gov_def_request_body(object_type: str, attributes: dict)->dict:
+    rel_body = set_rel_request_body(object_type, attributes)
+    rel_body["properties"] = {
+        "class" : "PeerDefinitionProperties",
+        "description": attributes.get('Description', {}).get('value', None),
+        "effectiveFrom": attributes.get('Effective From', {}).get('value', None),
+        "effectiveTo": attributes.get('Effective To', {}).get('value', None),
+        "label": attributes.get('Label', {}).get('value', None),
+        }
+    return rel_body
+
+def set_metadata_source_request_body(object_type: str, attributes: dict)->dict:
+    return {
+        "class": "MetadataSourceRequestBody",
+        "externalSourceGUID": attributes.get('External Source GUID', {}).get('guid', None),
+        "externalSourceName": attributes.get('External Source Name', {}).get('value', None),
+        "effectiveTime": attributes.get('Effective Time', {}).get('value', None),
+        "forLineage": attributes.get('For Lineage', {}).get('value', False),
+        "forDuplicateProcessing": attributes.get('For Duplicate Processing', {}).get('value', False)
+        }
+
+def set_filter_request_body(object_type: str, attributes: dict)->dict:
+    return {
+            "class": "FilterRequestBody",
+            "asOfTime": attributes.get('AsOfTime', {}).get('value', None),
+            "effectiveTime": attributes.get('Effective Time', {}).get('value', None),
+            "forLineage": attributes.get('For Lineage', {}).get('value', False),
+            "forDuplicateProcessing": attributes.get('For Duplicate Processing', {}).get('value', False),
+            "limitResultsByStatus": attributes.get('Limit Result by Status', {}).get('value', None),
+            "sequencingOrder": attributes.get('Sequencing Order', {}).get('value', None),
+            "sequencingProperty": attributes.get('Sequencing Property', {}).get('value', None),
+            "filter": attributes.get('Search String', {}).get('value', None),
+             }
+
+def set_element_status_request_body(object_type: str, attributes: dict)->dict:
+    return {
+        "class": f"{camel_to_title_case(object_type)}StatusRequestBody",
+        "status": attributes.get('Status', {}).get('value', None),
+        "externalSourceGUID": attributes.get('External Source GUID', {}).get('guid', None),
+        "externalSourceName": attributes.get('External Source Name', {}).get('value', None),
+        "effectiveTime": attributes.get('Effective Time', {}).get('value', None),
+        "forLineage": attributes.get('For Lineage', {}).get('value', False),
+        "forDuplicateProcessing": attributes.get('For Duplicate Processing', {}).get('value', False)
+    }