pyegeria 5.3.6.3__py3-none-any.whl → 5.3.6.4__py3-none-any.whl

pyegeria/_client.py

@@ -11,6 +11,7 @@ import asyncio
 import inspect
 import json
 import os
+import re
 from datetime import datetime
 
 import httpx
@@ -769,6 +770,15 @@ class Client:
         )
         return result
 
+    def __create_qualified_name__(self, type: str, display_name: str, local_qualifier: str = None) -> str:
+        """Helper function to create a qualified name for a given type and display name.
+           If present, the local qualifier will be prepended to the qualified name."""
+        EGERIA_LOCAL_QUALIFIER = os.environ.get("EGERIA_LOCAL_QUALIFIER", local_qualifier)
+        display_name = re.sub(r'\s','-',display_name.strip())
+        q_name = f"{type}:{display_name}"
+        if EGERIA_LOCAL_QUALIFIER:
+            q_name = f"{EGERIA_LOCAL_QUALIFIER}:{q_name}"
+        return q_name
 
 if __name__ == "__main__":
     print("Main-__client")

pyegeria/commands/cat/dr_egeria_md.py

@@ -8,7 +8,8 @@ from rich.console import Console
 from rich.markdown import Markdown
 
 from pyegeria.md_processing_utils import (extract_command, process_glossary_upsert_command, process_term_upsert_command,
-                                          get_current_datetime_string, process_per_proj_upsert_command, commands)
+                                          get_current_datetime_string, process_per_proj_upsert_command, commands,
+                                          process_provenance_command)
 
 import click
 from pyegeria import (extract_command, process_glossary_upsert_command, process_term_upsert_command,
@@ -76,7 +77,8 @@ def process_markdown_file(
         print(f"Error: File not found at path: {full_file_path}")
         return {}  # Return empty dict if file not found
 
-    final_output = (f"\n# Results from processing file {file_path} on "
+    final_output =""
+    prov_output = (f"\n* Results from processing file {file_path} on "
                     f"{datetime.now().strftime("%Y-%m-%d %H:%M")}\n")
     h1_blocks = []
     current_block = ""
@@ -103,13 +105,16 @@ def process_markdown_file(
 
     if current_block:  # Add the last H1 block
         h1_blocks.append(current_block)
-
+    prov_found = False
     # Process each identified H1 block
     for block in h1_blocks:
         potential_command = extract_command(block)  # Extract potential command
 
         if potential_command in commands:
             # Process the block based on the command
+            if potential_command == "Provenance":
+                prov_found = True
+                result = process_provenance_command(file_path, block)
             if potential_command in ["Create Glossary", "Update Glossary"]:
                 result = process_glossary_upsert_command(client, element_dictionary, block, directive)
             elif potential_command in ["Create Category", "Update Category"]:
@@ -125,7 +130,7 @@ def process_markdown_file(
             if result:
                 if directive == "process":
                     updated = True
-                    final_output += f"\n---\n{Markdown(result)}\n---\n\n"
+                    final_output += f"\n---\n{result}\n---\n\n"
                     print(json.dumps(element_dictionary, indent=4))
             elif directive == "process":
                 # Handle case with errors (skip this block but notify the user)
@@ -136,6 +141,7 @@ def process_markdown_file(
             # If no command is detected, add the block to the final output as-is
             final_output += f"\n---\n{block}\n---\n\n"
 
+
     # Write the final_output to a new file if updated
     try:
         if updated:
@@ -146,6 +152,9 @@ def process_markdown_file(
 
             with open(new_file_path, 'w') as f2:
                 f2.write(final_output)
+                if not prov_found:
+                    prov_output += f"\n# Provenance:\n{prov_output}\n"
+                f2.write(prov_output)
             click.echo(f"\n==> Notebook written to {new_file_path}")
         else:
             click.echo("\nNo updates detected. New File not created.")

pyegeria/commands/cli/egeria.py

@@ -34,7 +34,7 @@ from pyegeria.commands.cat.glossary_actions import (
     remove_term_from_category
 )
 from pyegeria.commands.cat.dr_egeria_jupyter import process_jupyter_notebook
-from pyegeria.commands.cat.dr_egeria_md_file import process_markdown_file
+from pyegeria.commands.cat.dr_egeria_md import process_markdown_file
 
 from pyegeria.commands.cat.list_categories import display_categories
 from pyegeria.commands.cat.list_assets import display_assets

pyegeria/glossary_browser_omvs.py

@@ -75,7 +75,7 @@ class GlossaryBrowser(Client):
                 - A string or None indicating the action description for the elements,
                   depending on the output format.
         """
-        search_string = search_string if search_string else "All Terms"
+        search_string = search_string if search_string else "All Elements"
         elements_action = "Update " + obj_type
         if output_format == "FORM":
             preamble = (f"\n# Update {obj_type} Form - created at {datetime.now().strftime('%Y-%m-%d %H:%M')}\n"
@@ -87,9 +87,22 @@ class GlossaryBrowser(Client):
                            f"\t{obj_type}  found from the search string:  `{search_string}`\n\n")
             elements_action = None
             return elements_md, elements_action
+
         else:
             return "\n", elements_action
 
+    def make_md_attribute(self, attribute_name: str, attribute_value: str, output_type: str) -> str | None:
+        output = ""
+        attribute_value = attribute_value.strip() if attribute_value else None
+        attribute_title = attribute_name.title() if attribute_name else None
+        if output_type in ["FORM", "MD"]:
+            output = f"## {attribute_title}\n{attribute_value}\n\n"
+        elif output_type == "REPORT":
+            if attribute_value:
+                output = f"## {attribute_title}\n{attribute_value}\n\n"
+        return output
+
+
     def generate_glossaries_md(self, elements: list | dict, search_string: str, output_format: str = 'MD')-> str:
         elements_md, elements_action = self.make_preamble(obj_type="Glossary", search_string=search_string,
                                                           output_format=output_format)
@@ -105,26 +118,26 @@ class GlossaryBrowser(Client):
             usage = properties.get("usage", None)
             qualified_name = properties.get("qualifiedName", None)
 
-            if output_format == 'FORM':
+            if output_format in ['FORM','MD']:
                 elements_md += f"# {elements_action}\n\n"
                 elements_md += f"## Glossary Name \n\n{display_name}\n\n"
-                elements_md += "## Update Description\n\n\n"
+
             elif output_format == 'REPORT':
                 elements_md += f"# Glossary Name: {display_name}\n\n"
             else:
                 elements_md += f"## Glossary Name \n\n{display_name}\n\n"
-                elements_md += "## Update Description\n\n\n"
 
-            elements_md += f"## Description\n{description}\n\n"
-            elements_md += f"## Language\n{language}\n\n"
-            elements_md += f"## Usage\n{usage}\n\n"
-            elements_md += f"## Qualified Name\n{qualified_name}\n\n"
-            elements_md += f"## GUID\n{guid}\n\n"
-            elements_md += MD_SEPERATOR
+            elements_md += self.make_md_attribute( "description", description, output_format)
+            elements_md += self.make_md_attribute("language", language, output_format)
+            elements_md += self.make_md_attribute("usage", usage, output_format)
+            elements_md += self.make_md_attribute("qualified name", qualified_name, output_format)
+            elements_md += self.make_md_attribute("GUID", guid, output_format)
+            # elements_md += MD_SEPERATOR
+
         return elements_md
 
     def generate_terms_md(self, elements: list | dict, search_string: str, output_format: str = 'MD') -> str:
-        elements_md, elements_action = self.make_preamble(obj_type="Terms", search_string=search_string, output_format=output_format)
+        elements_md, elements_action = self.make_preamble(obj_type="Term", search_string=search_string, output_format=output_format)
         if isinstance(elements, dict):
             elements = [elements]
 
@@ -140,34 +153,38 @@ class GlossaryBrowser(Client):
             qualified_name = element_properties.get("qualifiedName", None)
             status = element['elementHeader'].get('status', None)
 
+            glossary_guid = element['elementHeader'].get('classifications', [{}])[0].get('classificationProperties', {}).get('anchorGUID', None)
+            glossary_qualified_name = self.get_glossary_by_guid(glossary_guid)['glossaryProperties']['qualifiedName']
+
             category_list_md = "\n"
             category_list = self.get_categories_for_term(guid)
             if type(category_list) is str and category_list == NO_CATEGORIES_FOUND:
                 category_list_md = ['---']
             elif isinstance(category_list, list) and len(category_list) > 0:
                 for category in category_list:
-                    category_name = category["glossaryCategoryProperties"].get("displayName", '---')
+                    category_name = category["glossaryCategoryProperties"].get("qualifiedName", '---')
                     category_list_md += f" {category_name}\n"
 
-            if output_format == 'FORM':
+            if output_format in ['FORM', 'MD']:
                 elements_md += f"# {elements_action}\n\n"
                 elements_md += f"## Term Name \n\n{display_name}\n\n"
-                elements_md += "## Update Description\n\n\n"
             elif output_format == 'REPORT':
                 elements_md += f"# Term Name: {display_name}\n\n"
             else:
                 elements_md += f"## Term Name \n\n{display_name}\n\n"
-                elements_md += "## Update Description\n\n\n"
-            elements_md += f"## Categories\n\n{category_list_md}\n\n"
-            elements_md += f"## Status\n\n{status}\n\n"
-            elements_md += f"## Summary\n\n{summary}\n\n"
-            elements_md += f"## Description\n\n{description}\n\n"
-            elements_md += f"## Examples\n\n{examples}\n\n"
-            elements_md += f"## Usage\n\n{usage}\n\n"
-            elements_md += f"## Published Version\n\n{pub_version}\n\n"
-            elements_md += f"## Qualified Name\n\n{qualified_name}\n\n"
-            elements_md += f"## GUID\n\n{guid}\n\n"
-            elements_md += MD_SEPERATOR
+
+            elements_md += self.make_md_attribute("summary", summary, output_format)
+            elements_md += self.make_md_attribute("in glossary", glossary_qualified_name, output_format)
+            elements_md += self.make_md_attribute( "categories", category_list_md, output_format)
+            elements_md += self.make_md_attribute( "status", status, output_format)
+            elements_md += self.make_md_attribute( "description", description, output_format)
+            elements_md += self.make_md_attribute( "examples", examples, output_format)
+            elements_md += self.make_md_attribute("usage", usage, output_format)
+            elements_md += self.make_md_attribute("published version", pub_version, output_format)
+            elements_md += self.make_md_attribute("qualified name", qualified_name, output_format)
+            elements_md += self.make_md_attribute("GUID", guid, output_format)
+            # elements_md += MD_SEPERATOR
+
         return elements_md
 
     def generate_categories_md(self, elements: list | dict, search_string: str, output_format: str = 'MD')-> str:
@@ -190,21 +207,22 @@ class GlossaryBrowser(Client):
                 glossary_qualified_name = (
                     self.get_glossary_by_guid(glossary_guid))['glossaryProperties']['qualifiedName']
 
-            if output_format == 'FORM':
+            if output_format in ['FORM', 'MD']:
                 elements_md += f"# {elements_action}\n\n"
                 elements_md += f"## Category Name \n\n{display_name}\n\n"
-                elements_md += "## Update Description\n\n\n"
+
             elif output_format == 'REPORT':
                 elements_md += f"# Category Name: {display_name}\n\n"
             else:
                 elements_md += f"## Category Name \n\n{display_name}\n\n"
-                elements_md += "## Update Description\n\n\n"
 
-            elements_md += f"## Description\n{description}\n\n"
-            elements_md += f"## In Glossary (Qualified Name)\n{glossary_qualified_name}\n\n"
-            elements_md += f"## Qualified Name\n{qualified_name}\n\n"
-            elements_md += f"## GUID\n{guid}\n\n"
+
+            elements_md += self.make_md_attribute("description", description, output_format)
+            elements_md += self.make_md_attribute("in glossary", glossary_qualified_name, output_format)
+            elements_md += self.make_md_attribute("qualified name", qualified_name, output_format)
+            elements_md += self.make_md_attribute("GUID", guid, output_format)
             elements_md += MD_SEPERATOR
+
         return elements_md
 
     #

pyegeria/glossary_manager_omvs.py

@@ -100,7 +100,7 @@ class GlossaryManager(GlossaryBrowser):
             "class": "ReferenceableRequestBody",
             "elementProperties": {
                 "class": "GlossaryProperties",
-                "qualifiedName": f"Glossary:{display_name}",
+                "qualifiedName": self.__create_qualified_name__("Glossary", display_name),
                 "displayName": display_name,
                 "description": description,
                 "language": language,
@@ -351,7 +351,7 @@ class GlossaryManager(GlossaryBrowser):
             "class": "ReferenceableRequestBody",
             "elementProperties": {
                 "class": "GlossaryCategoryProperties",
-                "qualifiedName": f"GlossaryCategory-{display_name}-{time.asctime()}",
+                "qualifiedName": self.__create_qualified_name__("Category", display_name),
                 "displayName": display_name,
                 "description": description,
             },
@@ -936,9 +936,8 @@ class GlossaryManager(GlossaryBrowser):
                             continue
 
                 # Add the term
-                term_qualified_name = (
-                    f"GlossaryTerm: {term_name} - {datetime.now().isoformat()}"
-                )
+                term_qualified_name = self.__create_qualified_name("Term", display_name),
+
                 body = {
                     "class": "ReferenceableRequestBody",
                     "elementProperties": {

pyegeria/md_processing_utils.py

@@ -8,6 +8,8 @@ This file contains functions to parse and process Egeria Markdown (Freddie)
 import json
 from jupyter_notebook_parser import JupyterNotebookParser
 import nbformat
+from typing import List, Optional
+
 import os
 import re
 from pyegeria import EgeriaTech, NO_CATEGORIES_FOUND
@@ -23,12 +25,13 @@ import datetime
 
 console = Console(width=120)
 
-commands = ["Create Glossary", "Update Glossary", "Create Term", "Update Term", "Create Personal Project",
+commands = ["Provenance", "Create Glossary", "Update Glossary", "Create Term", "Update Term", "Create Personal Project",
             "Update Personal Project", "Create Category", "Update Category"]
 ERROR = "ERROR-> "
 INFO = "INFO- "
 WARNING = "WARNING-> "
 pre_command = "\n---\n==> Processing command:"
+EGERIA_LOCAL_QUALIFIER = os.environ.get("EGERIA_LOCAL_QUALIFIER", "PDR")
 element_dictionary = {}
 
 
@@ -44,18 +47,18 @@ def is_valid_iso_date(date_text) -> bool:
 def get_current_datetime_string():
     """Returns the current date and time as a human-readable string."""
     now = datetime.datetime.now()
-    return now.strftime("%Y%m%d%H%M%S")
+    return now.strftime("%Y-%m-%d-%H-%M")
 
 def add_term_to_categories(egeria_client: EgeriaTech, term_guid: str, categories_exist: bool, categories_list: [str], element_dictionary: dict)-> None:
     if categories_exist is True and categories_list is not None:
         for category in categories_list:
             cat_guid = None
-            cat_el = f"category.{category.strip()}"
+            cat_el = category.strip()
             if cat_el in element_dictionary:
                 cat= element_dictionary.get(cat_el, None)
                 cat_guid = cat.get('guid', None) if cat else None
             if cat_guid is None:
-                cat_guid = egeria_client.__get_guid__(property_name='displayName',display_name=category)
+                cat_guid = egeria_client.__get_guid__(qualified_name=category)
             egeria_client.add_term_to_category(term_guid, cat_guid)
 
 
@@ -67,36 +70,39 @@ def extract_command(block: str) -> str | None:
     return None
 
 
-def extract_attribute(text: str, label: str) -> str | None:
+def extract_attribute(text: str, labels: List[str]) -> str | None:
     """
         Extracts the glossary name from a string.
 
         Args:
             text: The input string.
-            label: The label to search for.
+            label: List of equivalent labels to search for
 
         Returns:
             The glossary name, or None if not found.
         """
-    pattern = r"## " + re.escape(label) + r"\n(.*?)(?:##|$)"  # Construct pattern
-    match = re.search(pattern, text, re.DOTALL)
-    if match and not match.group(1).isspace():
-        txt = match.group(1).strip()
-        return txt.strip()
-    return None
+    # Iterate over the list of labels
+    for label in labels:
+        # Construct pattern for the current label
+        pattern = rf"## {re.escape(label)}\n(.*?)(?:##|$)"
+        match = re.search(pattern, text, re.DOTALL)
+        if match and not match.group(1).isspace():  # Ensure extracted text is not blank
+            return match.group(1).strip()  # Return the matched text
+
+    return None  # Return None if no match is found
 
 
 def update_a_command(txt: str, command: str, obj_type: str, q_name: str, u_guid: str) -> str:
     u_guid = u_guid if u_guid else " "
     verb = command.split(' ')[0].strip()
     action = "Update" if (verb == "Create" and u_guid is not None) else "Create"
-    txt = txt.replace(f"{command}", f'**{action} {obj_type}**\n')  # update the command
-    txt = txt.replace('<GUID>', f'**GUID**\n{u_guid}')  # update with GUID
-    txt = txt.replace('<Qualified Name>', f"**Qualified Name**\n{q_name}")
+    txt = txt.replace(f"{command}", f'{action} {obj_type}\n')  # update the command
+    txt = txt.replace('<GUID>', f'GUID\n{u_guid}')  # update with GUID
+    txt = txt.replace('<Qualified Name>', f"Qualified Name\n{q_name}")
     if "Qualified Name" not in txt:
-        txt += f"\n## **Qualified Name**\n{q_name}\n"
+        txt += f"\n## Qualified Name\n{q_name}\n"
     if "GUID" not in txt:
-        txt += f"\n## **GUID**\n{u_guid}\n"
+        txt += f"\n## GUID\n{u_guid}\n"
 
     # if (command in {"Update Term", "Update Category", 'Update Glossary'}) and ("Update Description" not in txt):
     #     txt += '\n** Update Description\n\n\n'
@@ -112,6 +118,14 @@ def update_a_command(txt: str, command: str, obj_type: str, q_name: str, u_guid:
         txt = re.sub(pattern, replacement, txt)
     return txt
 
+def process_provenance_command(file_path: str, txt: str) -> str:
+    """This commands processes a provenence command by pre-pending the current file name and time to the provenance output"""
+    output = (f"* Derived from processing file {file_path} on "
+                    f"{datetime.now().strftime("%Y-%m-%d %H:%M")}\n")
+    existing_prov = extract_attribute(txt,'Provenance')
+    return f"# Provenance:\n{existing_prov}\n{output}\n"
+
+
 
 def process_glossary_upsert_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
                                     directive: str = "display") -> str | None:
@@ -128,19 +142,19 @@ def process_glossary_upsert_command(egeria_client: EgeriaTech, element_dictionar
     object_type = command.split(' ')[1].strip()
     object_action = command.split(' ')[0].strip()
 
-    glossary_name = extract_attribute(txt, 'Glossary Name')
+    glossary_name = extract_attribute(txt, ['Glossary Name'])
     print(Markdown(f"{pre_command} `{command}` for glossary: `\'{glossary_name}\'` with directive: `{directive}` "))
-    language = extract_attribute(txt, 'Language')
-    description = extract_attribute(txt, 'Description')
-    usage = extract_attribute(txt, 'Usage')
+    language = extract_attribute(txt, ['Language'])
+    description = extract_attribute(txt, ['Description'])
+    usage = extract_attribute(txt, ['Usage'])
 
     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':
-        q_name = extract_attribute(txt, 'Qualified Name')
-        guid = extract_attribute(txt, 'GUID')
+        q_name = extract_attribute(txt, ['Qualified Name'])
+        guid = extract_attribute(txt, ['GUID', 'guid', 'Guid'])
         glossary_display += f"* Qualified Name: {q_name}\n\t* GUID: {guid}\n\n"
 
     def validate_glossary(obj_action: str) -> tuple[bool, bool, str | None, str | None]:
@@ -236,11 +250,11 @@ def process_glossary_upsert_command(egeria_client: EgeriaTech, element_dictionar
                 }
             egeria_client.update_glossary(known_guid, body)
             print(f"\n-->Updated Glossary {glossary_name} with GUID {known_guid}")
-            element_dictionary[f"glossary.{glossary_name}"] = {
-                'guid': known_guid, 'q_name': known_q_name
+            element_dictionary[known_q_name] = {
+                'guid': known_guid, 'display_name': glossary_name
                 }
             # return update_a_command(txt, command, object_type, known_q_name, known_guid)
-            return egeria_client.get_glossary_by_guid(known_guid, output_format='md')
+            return egeria_client.get_glossary_by_guid(known_guid, output_format='MD')
         elif object_action == "Create":
             glossary_guid = None
 
@@ -254,11 +268,11 @@ def process_glossary_upsert_command(egeria_client: EgeriaTech, element_dictionar
                     print(f"{ERROR}Just created with GUID {glossary_guid} but Glossary not found\n")
                     return None
                 qualified_name = glossary['glossaryProperties']["qualifiedName"]
-                element_dictionary[f"glossary.{glossary_name}"] = {
-                    'guid': glossary_guid, 'q_name': qualified_name
+                element_dictionary[qualified_name] = {
+                    'guid': glossary_guid, 'display_name': glossary_name
                     }
                 # return update_a_command(txt, command, object_type, qualified_name, glossary_guid)
-                return egeria_client.get_glossary_by_guid(glossary_guid, output_format = 'md')
+                return egeria_client.get_glossary_by_guid(glossary_guid, output_format = 'MD')
 
 
 def process_categories_upsert_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
@@ -276,19 +290,20 @@ def process_categories_upsert_command(egeria_client: EgeriaTech, element_diction
     object_type = command.split(' ')[1].strip()
     object_action = command.split(' ')[0].strip()
 
-    category_name = extract_attribute(txt, 'Category Name')
+    category_name = extract_attribute(txt, ['Category Name', 'category_name', 'Cat'])
     print(Markdown(f"{pre_command} `{command}` for category: `\'{category_name}\'` with directive: `{directive}` "))
-    owning_glossary = extract_attribute(txt, 'Owning Glossary')
-    description = extract_attribute(txt, 'Description')
-    category_display = (f"\n* Command: {command}\n\t* Category: {category_name}\n\t"
-                        f"* In Glossary: {owning_glossary}\n\t* Description:\n{description}\n")
+    owning_glossary_qn = extract_attribute(txt, ['Owning Glossary', '[In Glossary'])
+    description = extract_attribute(txt, ['Description'])
+    q_name = extract_attribute(txt, ['Qualified Name'])
+
+    category_display = (f"\n* Command: {command}\n\t* Category: {category_name}\n\t* In Glossary: {owning_glossary_qn}\n\t"
+                        f"* Description:\n{description}\n\t* Qualified Name: {q_name}\n\t")
     update_description = None
 
     if object_action == 'Update':
-        q_name = extract_attribute(txt, 'Qualified Name')
-        guid = extract_attribute(txt, 'GUID')
+        guid = extract_attribute(txt, ['GUID','guid','Guid'])
         update_description = extract_attribute(txt, 'Update Description')
-        category_display += (f"* Qualified Name: {q_name}\n\t* GUID: {guid}\n\n"
+        category_display += (f"* GUID: {guid}\n\n"
                              f"* Update Description: \n {update_description}\n\t")
 
     def validate_category(obj_action: str) -> tuple[bool, bool, str | None, str | None, str | None]:
@@ -303,28 +318,33 @@ def process_categories_upsert_command(egeria_client: EgeriaTech, element_diction
             category_exists = False
         else:
             category_exists = True
-        el_glossary = f"glossary.{owning_glossary}"
-        if owning_glossary is None:
-            msg += f"* {ERROR}Owning Glossary is missing\n"
+
+        if owning_glossary_qn is None:
+            msg += f"* {ERROR}Owning Glossary Qualified Name is missing\n"
             valid = False
 
-        elif el_glossary in element_dictionary:  # Check to see if we already know about this glossary
-            owning_glossary_el = f"glossary.{owning_glossary}"
-            glossary_guid = element_dictionary[owning_glossary_el].get('guid', None)
-            glossary_q_name = element_dictionary[owning_glossary_el].get('q_name', None)
+        elif owning_glossary_qn in element_dictionary:  # Check to see if we already know about this glossary
+            glossary_name = element_dictionary[owning_glossary_qn].get('display_name', None)
+            glossary_guid = element_dictionary[owning_glossary_qn].get('guid', None)
+
         else:
             # need to ask Egeria if it knows the Glossary Name
-            glossary = egeria_client.get_glossaries_by_name(owning_glossary)
+            glossary = egeria_client.get_glossaries_by_name(owning_glossary_qn)
             if glossary == NO_GLOSSARIES_FOUND:
-                msg += f"* {ERROR}Glossary `{owning_glossary}` does not exist\n\n"
+                msg += f"* {ERROR}Glossary `{owning_glossary_qn}` does not exist\n\n"
                 valid = False
             else:
-                msg += f"* {INFO}Glossary `{owning_glossary}` exists\n\n"
+                msg += f"* {INFO}Glossary `{owning_glossary_qn}` exists\n\n"
                 glossary_guid = glossary[0]['elementHeader'].get('guid', None)
-                glossary_q_name = glossary[0]['glossaryProperties'].get('qualifiedName', None)
-                element_dictionary[el_glossary] = {
-                    'guid': glossary_guid, 'q_name': glossary_q_name
-                    }
+                glossary_name = glossary[0]['glossaryProperties'].get('displayName', None)
+                glossary_qn = glossary[0]['glossaryProperties'].get('qualifiedName', None)
+                if glossary_qn != owning_glossary_qn: # we were given the right qualified name - maybe a display_name
+                    msg += f"* {ERROR}Glossary `{owning_glossary_qn}` is known by qualifiedName `{glossary_qn}`\n\n"
+                    valid = False
+                else:
+                    element_dictionary[owning_glossary_qn] = {
+                        'guid': glossary_guid, 'display_name': glossary_name
+                        }
 
         if category_name is None:
             msg = f"* {ERROR}Category name is missing\n"
@@ -396,11 +416,11 @@ def process_categories_upsert_command(egeria_client: EgeriaTech, element_diction
             egeria_client.update_category(glossary_guid, category_name, description, known_q_name, None,
                                           update_description)
             print(f"\n-->Updated category `{category_name}`with GUID {known_guid}")
-            element_dictionary[f"category.{category_name}"] = {
-                'guid': known_guid, 'q_name': known_q_name
+            element_dictionary[known_q_name] = {
+                'guid': known_guid, 'display_name': category_name
                 }
             # return update_a_command(txt, command, object_type, known_q_name, known_guid)
-            return egeria_client.get_categories_by_guid(known_guid, output_format='md')
+            return egeria_client.get_categories_by_guid(known_guid, output_format='FORM')
 
         elif object_action == "Create":
             is_root = False
@@ -416,11 +436,11 @@ def process_categories_upsert_command(egeria_client: EgeriaTech, element_diction
                     print(f"{ERROR}Just created with GUID {category_guid} but category not found\n")
                     return None
                 qualified_name = category['glossaryCategoryProperties']["qualifiedName"]
-                element_dictionary[f"category.{category_name}"] = {
-                    'guid': category_guid, 'q_name': qualified_name
+                element_dictionary[qualified_name] = {
+                    'guid': category_guid, 'display_name': category_name
                     }
                 # return update_a_command(txt, command, object_type, qualified_name, category_guid)
-                return egeria_client.get_categories_by_guid(category_guid, output_format='md')
+                return egeria_client.get_categories_by_guid(category_guid, output_format='MD')
 
 def process_term_upsert_command(egeria_client: EgeriaTech, element_dictionary: dict, txt: str,
                                 directive: str = "display") -> str | None:
@@ -438,30 +458,39 @@ def process_term_upsert_command(egeria_client: EgeriaTech, element_dictionary: d
     object_type = command.split(' ')[1].strip()
     object_action = command.split(' ')[0].strip()
 
-    term_name = extract_attribute(txt, 'Term Name')
-    summary = extract_attribute(txt, 'Summary')
-    description = extract_attribute(txt, 'Description')
-    abbreviation = extract_attribute(txt, 'Abbreviation')
-    examples = extract_attribute(txt, 'Examples')
-    usage = extract_attribute(txt, 'Usage')
-    status = extract_attribute(txt, 'Status')
-    version = extract_attribute(txt, 'Version')
-    categories = extract_attribute(txt, 'Categories')
+    term_name = extract_attribute(txt, ['Term Name'])
+    summary = extract_attribute(txt, ['Summary'])
+    description = extract_attribute(txt, ['Description'])
+    abbreviation = extract_attribute(txt, ['Abbreviation'])
+    examples = extract_attribute(txt, ['Examples'])
+    usage = extract_attribute(txt, ['Usage'])
+    status = extract_attribute(txt, ['Status'])
+    version = extract_attribute(txt, ['Version', "Version Identifier"])
+    categories = extract_attribute(txt, ['Categories'])
+    q_name = extract_attribute(txt, ['Qualified Name'])
+    # q_name = q_name if q_name else " "
+
     categories_list = None
     cats_exist = True
 
-    glossary_name = extract_attribute(txt, 'Glossary Name')
+    glossary_qn = extract_attribute(txt, ['In Glossary','Owning Glossary'])
 
     print(Markdown(f"{pre_command} `{command}` for term: `\'{term_name}\'` with directive: `{directive}`"))
 
     def validate_term(obj_action: str) -> tuple[bool, bool, str | None, str | None]:
-        nonlocal version, status, categories, categories_list, cats_exist
+        nonlocal version, status, categories, categories_list, cats_exist, q_name
         valid = True
         msg = ""
         known_term_guid = None
         known_q_name = None
 
-        term_details = egeria_client.get_terms_by_name(term_name)
+        # If the user has specified a qualified_name then use it to look for matching terms.
+        # If not, use the display_name.
+        if q_name:
+            term_details = egeria_client.get_terms_by_name(q_name)
+        else:
+            term_details = egeria_client.get_terms_by_name(term_name)
+
         if term_details == NO_TERMS_FOUND:
             term_exists = False
         else:
@@ -475,28 +504,33 @@ def process_term_upsert_command(egeria_client: EgeriaTech, element_dictionary: d
         if term_name is None:
             msg = f"* {ERROR}Term name is missing\n"
             valid = False
-        if glossary_name is None:
-            msg += f"* {ERROR}Glossary name is missing\n"
+        if glossary_qn is None:
+            msg += f"* {ERROR}Glossary qualified name is missing\n"
             valid = False
         else:
-            glossary_el = f"glossary.{glossary_name}"
-            if glossary_el not in element_dictionary:
-                glossary = egeria_client.get_glossaries_by_name(glossary_name)
+            if glossary_qn not in element_dictionary:
+                glossary = egeria_client.get_glossaries_by_name(glossary_qn) #assuming q_name?
                 if isinstance(glossary,str):
-                    msg += f"* {ERROR}Glossary `{glossary_name}` is unknown\n "
+                    msg += f"* {ERROR}Glossary `{glossary_qn}` is unknown\n "
                     valid = False
+                else:
+                    element_dictionary[glossary_qn] = {
+                        'guid': glossary[0]['elementHeader'].get('guid', None),
+                        'display_name': glossary[0]['glossaryProperties'].get('displayName', None)
+                        }
+
 
         if categories is None:
-            msg += f"* {INFO}Categories are missing\n"
+            msg += f"* {INFO} No categories found\n"
         else:
             categories_list = re.split(r'[,\n]+', categories)
             categories = ""
             for category in categories_list:
-                category_el = f"category.{category.strip()}"
+                category_el = category.strip()
                 if category_el not in element_dictionary:
-                    cat = egeria_client.get_categories_by_name(category)
+                    cat = egeria_client.get_categories_by_name(category) # assuming qualified name?
                     if isinstance(cat,str):
-                        msg += (f"* {WARNING}Category `{category}` is unknown to validate -> "
+                        msg += (f"* {WARNING}Category `{category}` not found -> "
                                 f"categories for this term won't be processed!\n")
                         cats_exist = False
                 categories = f"{category}, {categories}"
@@ -519,8 +553,10 @@ def process_term_upsert_command(egeria_client: EgeriaTech, element_dictionary: d
         if usage is None:
             msg += f"* {INFO}Term usage is missing\n"
         if version is None:
-            msg += f"* {INFO}Term version is missing - will default to 0.0.1\n"
-            version = "0.0.1"
+            msg += f"* {INFO}Term version is missing\n"
+            # version = "0.0.1"
+
+
 
         if obj_action == "Update":  # check to see if provided information exists and is consistent with existing info
             if not term_exists:
@@ -528,7 +564,8 @@ def process_term_upsert_command(egeria_client: EgeriaTech, element_dictionary: d
                 valid = False
 
             if len(term_details) > 1 and term_exists:
-                msg += f"* {ERROR}More than one term with name {term_name} found\n"
+                msg += (f"* {ERROR}More than one term with name {term_name} found, please specify a "
+                        f"**Qualified Name**\n")
                 valid = False
             elif len(term_details) == 1:
                 known_term_guid = term_details[0]['elementHeader'].get('guid', None)
@@ -537,7 +574,7 @@ def process_term_upsert_command(egeria_client: EgeriaTech, element_dictionary: d
                 msg += (f"* {ERROR}Term {term_name} qualifiedName mismatch between {q_name} and {known_q_name}\n")
                 valid = False
             else:
-                msg += f"--> * Term {term_name} exists and can be updated\n"
+                msg += f"\n--> * Term {term_name} exists and can be updated\n"
                 msg += term_display
 
             print(Markdown(msg))
@@ -554,15 +591,15 @@ def process_term_upsert_command(egeria_client: EgeriaTech, element_dictionary: d
             print(Markdown(msg))
             return valid, term_exists, known_term_guid, known_q_name
 
+
     if object_action == "Update":
         term_guid = extract_attribute(txt, 'GUID')
         term_guid = term_guid if term_guid else " "
-        q_name = extract_attribute(txt, 'Qualified Name')
-        q_name = q_name if q_name else " "
+
 
         update_description = extract_attribute(txt, 'Update Description')
         update_description = update_description if update_description else " "
-        term_display = (f"\n* Command: {command}\n\t* Glossary: {glossary_name}\n\t"
+        term_display = (f"\n* Command: {command}\n\t* Glossary: {glossary_qn}\n\t"
                         f"* Term Name: {term_name}\n\t* Categories: {categories}\n\t* Summary: {summary}"
                         f"\n\t* Description: {description}\n\t"
                         f"* Abbreviation: {abbreviation}\n\t* Examples: {examples}\n\t* Usage: {usage}\n\t"
@@ -570,7 +607,7 @@ def process_term_upsert_command(egeria_client: EgeriaTech, element_dictionary: d
                         f"{q_name}"
                         f"\n\t* Update Description: {update_description}\n")
     else:
-        term_display = (f"\n* Command: {command}\n\t* Glossary: {glossary_name}\n\t"
+        term_display = (f"\n* Command: {command}\n\t* Glossary: {glossary_qn}\n\t"
                         f"* Term Name: {term_name}\n\t* Categories: {categories}\n\t* Summary: {summary}\n\t"
                         f"* Description: {description}\n\t"
                         f"* Abbreviation: {abbreviation}\n\t* Examples: {examples}\n\t* Usage: {usage}\n\t"
@@ -618,23 +655,24 @@ def process_term_upsert_command(egeria_client: EgeriaTech, element_dictionary: d
 
             elif object_action == "Create":
                 guid = None
-                q_name = f"GlossaryTerm:{term_name}:{get_current_datetime_string()}"
+
+                q_name = egeria_client.__create_qualified_name__("Term",term_name, EGERIA_LOCAL_QUALIFIER)
                 if exists:
                     print(f"\n{WARNING}Term {term_name} exists and result document updated")
                     return update_a_command(txt, command, object_type, q_name, known_guid)
                 else:
                     ## get the guid for the glossary from the name - first look locally
-                    glossary = element_dictionary.get(f"glossary.{glossary_name}", None)
+                    glossary = element_dictionary.get(glossary_qn, None)
 
                     if glossary is not None:
                         glossary_guid = glossary.get('guid', None)
                         if glossary_guid is None:
-                            print(f"{ERROR}Glossary reference {glossary_name} not found")
+                            print(f"{ERROR}Glossary reference {glossary_qn} not found")
                             return None
                     else:
-                        glossary_guid = egeria_client.__get_guid__(property_name="displayName", display_name=glossary_name)
+                        glossary_guid = egeria_client.__get_guid__(qualified_name=glossary_qn)
                         if glossary_guid == NO_ELEMENTS_FOUND:
-                            print(f"{ERROR}Glossary {glossary_name} not found")
+                            print(f"{ERROR}Glossary {glossary_qn} not found")
                             return None
                     term_body = {
                         "class": "ReferenceableRequestBody", "elementProperties": {
@@ -657,9 +695,8 @@ def process_term_upsert_command(egeria_client: EgeriaTech, element_dictionary: d
                         egeria_client, term_guid, cats_exist, categories_list,
                         element_dictionary)
                     print(f"\n-->Created Term {term_name} with GUID {term_guid}")
-                    # element = egeria_client.find_glossary_terms('term_name')
-                    element_dictionary[f"term.{term_name}"] = {'guid': term_guid, 'q_name': q_name}
-                    return egeria_client.get_terms_by_guid(term_guid, 'md')
+                    element_dictionary[q_name] = {'guid': term_guid, 'display_name': term_name}
+                    return egeria_client.get_terms_by_guid(term_guid, 'MD')
                     # return update_a_command(txt, command, object_type, q_name, term_guid)
         except Exception as e:
             print(f"{ERROR}Error creating term {term_name}: {e}")
@@ -682,14 +719,14 @@ def process_per_proj_upsert_command(egeria_client: EgeriaTech, element_dictionar
     object_type = f"{object[1]} {object[2]}"
     object_action = object[0]
 
-    project_name = extract_attribute(txt, 'Project Name')
-    description = extract_attribute(txt, 'Description')
-    project_identifier = extract_attribute(txt, 'Project Identifier')
-    project_status = extract_attribute(txt, 'Project Status')
-    project_phase = extract_attribute(txt, 'Project Phase')
-    project_health = extract_attribute(txt, 'Project Health')
-    start_date = extract_attribute(txt, 'Start Date')
-    planned_end_date = extract_attribute(txt, 'Planned End Date')
+    project_name = extract_attribute(txt, ['Project Name'])
+    description = extract_attribute(txt, ['Description'])
+    project_identifier = extract_attribute(txt, ['Project Identifier'])
+    project_status = extract_attribute(txt, ['Project Status'])
+    project_phase = extract_attribute(txt, ['Project Phase'])
+    project_health = extract_attribute(txt, ['Project Health'])
+    start_date = extract_attribute(txt, ['Start Date'])
+    planned_end_date = extract_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"
@@ -812,5 +849,5 @@ def process_per_proj_upsert_command(egeria_client: EgeriaTech, element_dictionar
                     return None
 
                 q_name = project_g['projectProperties']["qualifiedName"]
-                element_dictionary[f"project.{project_name}"] = {'guid': guid, 'q_name': q_name}
+                element_dictionary[q_name] = {'guid': guid, 'display_name': project_name}
                 return update_a_command(txt, command, object_type, q_name, guid)

{pyegeria-5.3.6.3.dist-info → pyegeria-5.3.6.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pyegeria
-Version: 5.3.6.3
+Version: 5.3.6.4
 Summary: A python client for Egeria
 License: Apache 2.0
 Keywords: egeria,metadata,governance

{pyegeria-5.3.6.3.dist-info → pyegeria-5.3.6.4.dist-info}/RECORD

@@ -1,6 +1,6 @@
 pyegeria/README.md,sha256=PwX5OC7-YSZUCIsoyHh1O-WBM2hE84sm3Bd4O353NOk,1464
 pyegeria/__init__.py,sha256=08v01IyeVZ-YlRZU0qGPAGDhNsdEscX1IHvPcsAYZrE,30187
-pyegeria/_client.py,sha256=aeyB27WFxswxcIj_Ky88F2Q4S5zn7ofmux65aen5mW0,31130
+pyegeria/_client.py,sha256=nhUPmeQFHqbobM6_3EGmUy-STYURxb15BEXf6erY2oI,31733
 pyegeria/_deprecated_gov_engine.py,sha256=dWNcwVsE5__dF2u4QiIyQrssozzzOjBbLld8MdpmVCQ,17264
 pyegeria/_exceptions.py,sha256=1SrnV194V4_YJNnNAU0myTHQ3dhLn4GF2B2gZcj1u90,18153
 pyegeria/_globals.py,sha256=a_irI6oGuBLks2LzQHkSdK6xWbPdJCPRjqxK7PKxwgw,991
@@ -13,11 +13,10 @@ pyegeria/commands/README.md,sha256=hJdOWhZ5eCfwTkY4Tx6De6Y1XVo7cbaddQEvjqppvls,2
 pyegeria/commands/__init__.py,sha256=R2o66ctVicTZ8B5VSPtc7EDRKNiNclzFbYX0o2Zg2dQ,1120
 pyegeria/commands/cat/README.md,sha256=-aaAnIT2fcfU63vajgB-RzQk4l4yFdhkyVfSaTPiqRY,967
 pyegeria/commands/cat/__init__.py,sha256=5OCy4m_yZsnSxdy_gvkCyP_OkjvuWKimqUGHYCJc_qA,450
-pyegeria/commands/cat/dr_egeria_inbox/freddie_intro.md,sha256=xiikqqouWFBTCCBgZh7SXTaIy61i7fTWN9J2zbvZ2Ao,6548
 pyegeria/commands/cat/dr_egeria_inbox/glossary_creation_experiment.ipynb,sha256=dbzNu90fCKNohOWVSRBOB1GLyd95x8Qw51I5AkaPtso,11552
 pyegeria/commands/cat/dr_egeria_inbox/glossary_exp.md,sha256=KsUeTzDe5QkrTmIfIAXR74qZ29oSfRW-NAEn0RYIRqM,2534
 pyegeria/commands/cat/dr_egeria_jupyter.py,sha256=4LcmD5CrtazLgUK_LCjgOnwtxZqTBB6lrMR8tsugl94,6036
-pyegeria/commands/cat/dr_egeria_md.py,sha256=9x4Iadk252Njr0VN_oiG4UOAVpEkeIYSXeGLg-JLKFs,7274
+pyegeria/commands/cat/dr_egeria_md.py,sha256=jMioOrViTFuExh8AlFpJvrEZt4U5I9oUICvKhQPx4D0,7675
 pyegeria/commands/cat/exp_list_glossaries.py,sha256=dC6Bnfm3YSMTKPP146qeslIFRiZnGu5b7iDYE07p4iU,5817
 pyegeria/commands/cat/get_asset_graph.py,sha256=xnXJfpDTVH1TJ2TwE3dtjaXU36Di6-N6JAyhothzz2o,12461
 pyegeria/commands/cat/get_collection.py,sha256=KbSFoGZeK30_bMCa0BpIuCwBF5ywCX0g4hgDPnI0lEo,5356
@@ -41,7 +40,7 @@ pyegeria/commands/cat/list_terms.py,sha256=D0tCD2f8j-UgnV4Bgisj9a11CCEOneNsRT7_3
 pyegeria/commands/cat/list_todos.py,sha256=NitCw0uyVVjmN1hxb1W-I4FbOsa8wQxW2ICyOElHyc8,6556
 pyegeria/commands/cat/list_user_ids.py,sha256=X5Q-YNEp38saPYDuy9VwdQC5Qpa4HyC3WvAdbyp_P6M,5108
 pyegeria/commands/cli/__init__.py,sha256=hpTVSMP2gnPRhcAZPdeUEsQ-eaDySlXlk239dNWYmng,292
-pyegeria/commands/cli/egeria.py,sha256=gT_gNVXCrd5_sR9KLoJ56CCW5T0d8cYuNBTGAJ9UVfk,52640
+pyegeria/commands/cli/egeria.py,sha256=Rtqru3Dp61SspzMVQ_UMHhtPc4_kq7S3Ocf-SqdfTN0,52635
 pyegeria/commands/cli/egeria_cat.py,sha256=_1qA7PS3fMH22j9BTGqFLnqVOTMRewP8-6jIPBvjuCI,18237
 pyegeria/commands/cli/egeria_login_tui.py,sha256=W5ouG3nlN7z2Waa-wzYFS7yyoGfOrK-lNB0FMt2JdOk,9492
 pyegeria/commands/cli/egeria_my.py,sha256=0KTH7OIeKyp16ZeN7zK5uhadbPfAQsq38GMzJNWYG8g,6386
@@ -225,10 +224,10 @@ pyegeria/egeria_my_client.py,sha256=eOKLk2zdI6FHZnhAimfR_0yNdBjpUgD41dJZcJODcqE,
 pyegeria/egeria_tech_client.py,sha256=uycgYfCpb4jzFfaQ7I5JxbZ5PKsWdaWxLOJjbw6C2Zk,3817
 pyegeria/feedback_manager_omvs.py,sha256=0xBs0p54vmdfVYYgQ8pOanLC4fxfgTk1Z61Y6D1U7_I,152978
 pyegeria/full_omag_server_config.py,sha256=CQqLCy_3DZFvJZEOcGf50HWdFaWpiAIs6z-kKyjvpDA,47464
-pyegeria/glossary_browser_omvs.py,sha256=EA8yP7U0l8nJQi10GFEnzNecElqCy9VVBsKCGL6N4pM,108297
-pyegeria/glossary_manager_omvs.py,sha256=73dTj-o6qBiQx02oe1ixpk-BTy_KrSFPTDDkf0R_bgI,70287
+pyegeria/glossary_browser_omvs.py,sha256=r8PYlNTN-Ej2pGg1SigKQn8Qu1wDmFvWG5vM2I12JyI,109391
+pyegeria/glossary_manager_omvs.py,sha256=QSOVqbwEASueCQzpvYNEOaUIAhOvwqLWWhfzwT8hrrs,70275
 pyegeria/m_test.py,sha256=M5-M2ZczsAJLXWfSeqTTADHdx6Ku-y4PbQ4M21JthAE,7778
-pyegeria/md_processing_utils.py,sha256=ZanhxWd9wkr0OwUSfjUqXJ40wk7ewfaMXri96g-X4zA,38736
+pyegeria/md_processing_utils.py,sha256=FiZqeN39YH9LeZvzY_YZ8wo6DnRRvQif3-BBHLebcBg,40329
 pyegeria/mermaid_utilities.py,sha256=sQqdFUWdNpHu9d3Tk9UVe80M-5bOzses0XcFYX5FF-E,54254
 pyegeria/metadata_explorer_omvs.py,sha256=xHnZTQKbd6XwOhYia-RiIisrvZcqHi0SL1l6OCf04Gk,86911
 pyegeria/my_profile_omvs.py,sha256=d0oJYCJG7pS9BINPuGciVa00ac0jwPHNANXDCLginEc,34720
@@ -242,8 +241,8 @@ pyegeria/template_manager_omvs.py,sha256=PfJ9dOfmBvf59DgRdZ9Dl1Kl_UYqjF-JncXVnbC
 pyegeria/utils.py,sha256=GCt1C0bp0Xng1ahzbZhzV9qQwH7Dj93IaCt2dvWb-sg,5417
 pyegeria/valid_metadata_omvs.py,sha256=Xq9DqBQvBFFJzaFIRKcVZ2k4gJvSh9yeXs_j-O3vn1w,65050
 pyegeria/x_action_author_omvs.py,sha256=RcqSzahUKCtvb_3u_wyintAlc9WFkC_2v0E12TZs8lQ,6433
-pyegeria-5.3.6.3.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-pyegeria-5.3.6.3.dist-info/METADATA,sha256=Bkhxmvi9XtEUypSiTRWVemi1BIXdo6paMT7-PRe0B30,2743
-pyegeria-5.3.6.3.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-pyegeria-5.3.6.3.dist-info/entry_points.txt,sha256=eAvQ_vkejlF3JzMzEc5VD93ymLA_hSFV0HM8fntG-d8,6791
-pyegeria-5.3.6.3.dist-info/RECORD,,
+pyegeria-5.3.6.4.dist-info/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyegeria-5.3.6.4.dist-info/METADATA,sha256=yd4UPOQI1S90JJ0hO89N5EIKSu6t5CvWuywJ9c4PFh4,2743
+pyegeria-5.3.6.4.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+pyegeria-5.3.6.4.dist-info/entry_points.txt,sha256=eAvQ_vkejlF3JzMzEc5VD93ymLA_hSFV0HM8fntG-d8,6791
+pyegeria-5.3.6.4.dist-info/RECORD,,

pyegeria/commands/cat/dr_egeria_inbox/freddie_intro.md

@@ -1,269 +0,0 @@
-
-# Introduction to Freddie - an Egeria Markdown Processor
-
-
-A constant challenge in managing information is gathering enough metadata about the information to
-allow us to manage it. A common approach is to build fancy graphical user interfaces hoping that they
-will be attractive enough and easy enough to use that people will do so.
-
-Unfortunately, however, this ignores the fundamental fact that to use one of these nice GUI
-applications, you have to step away from the tools and processes that you were in the midst of performing.
-You have to leave your world and enter a new, often less familiar one.
-
-Freddie, is an experiment in turning this around. Its not that fancy graphical user
-interfaces don't have a role - but rather, to look at what we can do to support the
-tools and approaches people already use. And maybe even make their day job a little
-easier.
-
-So this is what we are exploring with Freddie. An Egeria Markdown language that allows
-users to intermix requests to Egeria with other text through the use of standard Markdown.
-
-This file is an example. You will see that we intersperse normal narrative text (such as this)
-with Commands to Egeria. We introduce a specific vocabulary to make Egeria requests.
-
-In the example below we will create a new Egeria glossary to hold definitions related to Freddie:
----
-
-# Create Glossary
-
-## Glossary Name
-
-test
-
-## Language
-
-English
-
-## Description
-
-Glossary to describe the vocabulary of Freddie - an Egeria Markdown language to support the exchange of metadata in a
-Markdown form.
-Freddie allows users to input metadata using any text entry system that supports the entry of standard Markdown
-characters and through post-processing
-commands, validates the Egeria content and allows the requests to be sent to Egeria. This is an update
-
-## Usage
-
-a quick test glossary
-## <Qualified Name>
-
-## <GUID>
-
----
-
-# First Walk-Through
-The block of markdown above is a request to create a new Egeria Glossary called `Egeria-Markdown`. Let's briefly walk
-through. The command starts when we see `# Create Glossary`. This is a known phrase in Freddie. When we see this 
-phrase we recognize that this is an egeria markdown request block. The request block ends if we encounter another `#` or
-`---`, or run out of text. Within this request block we note some **attributes** that begin with a `## `. The first that
-we encounter is `## Glossary Name`. Not all attributes need to be filled in. Later, we'll process this file and demonstrate 
-how to tell - but first, lets look at the attributes shown:
-
-* `## Glossary Name` - this is the display name of the glossary. In this case the name is `Egeria-Markdown` As you can 
-see, the value of the attribute is the plain text that follows it.
-* `## Language` - what language will the terms of the glossary be in (yes there are ways to have mixed language but
-Freddie strives to be as simple as possible).
-* `## Description` - a description of the glossary and its purpose.
-* `## Usage` - how the glossary is meant to be used and by whom.
-* `## <Qualified Name>` - every element in Egeria must have a unique qualified name that we use to distinguish 
-it from all other elements. The qualified name is meant to be understandable by humans, although it may follow 
-formatting conventions. This attributes is in angle brackets because at this point we can't fill it in - we are just
-in the midst of creating the glossary. A qualified name will be created for us as part of the glossary creation. We'll
-see a little later how we get that.
-* `## <GUID>` - same story as qualified name except that this is meant for automation and not people.
-
-And that's it. That's all we need to do to specify the creation of a new glossary (well - mostly - we'll reveal a few 
-more details a bit later).
-
-## Great! That was easy!
-
-We now have a nice, clean, new...and empty...glossary - guess we better start filling it. Lets create a couple of terms.
-
----
-
-# Create Category
-
-## Category Name
-
-cat1
-
-## Owning Glossary
-
-test
-
-## Description
-
-These terms describe features of writing markdown files that can use Egeria-Markdown
-
-
-## <Qualified Name>
-
-## <GUID>
-
----
-
-# Create Category
-
-## Category Name
-
-cat2
-
-## Owning Glossary
-
-test
-
-## Description
-
-These terms describe concepts related to processing Egeria-Markdown
-
-
-## <Qualified Name>
-
-## <GUID>
----
-
-# Create Term
-
-## Glossary Name
-
-test
-
-## Term Name
-
-t1
-
-## Categories
-
-cat1, cat2
-
-## Summary
-
-Commands are how a user of the Freddie markdown language requests an action.
-
-## Description
-
-Commands are how a user can request Egeria to take an action such as Create or Update an Egeria element. Freddie
-provides
-a limited (but growing) set of commands. Freddie commands align with the pyegeria 'hey-egeria' command line interface.
-
-## Abbreviation
-
-## Examples
-
-Create Glossary or
-Update Glossary or
-Create Term or
-Update Term
-
-## Usage
-
-Commands are used in the Freddie Egeria markdown language.
-
-## Version
-
-v1
-
-## Status
-
-
-## Qualified Name
-
----
-
-# Create Term
-
-## Glossary Name
-
-test
-
-## Term Name
-
-t2
-
-## Categories
-Writing Markdown
-
-Processing Markdown
-
-## Summary
-
-Source of the markdown content.
-
-## Description
-
-Source of the markdown content - could be jupter or plain markdown file.
-
-## Abbreviation
-
-## Examples
-
-## Usage
-
-## Version
-
-0.1
-
-## Status
-
-DRAFT
-
-
----
-
-# Create Term
-
-## Glossary Name
-
-Egeria-Markdown
-
-## Term Name
-
-Directive
-
-## Categories
-
-meow mix
-
-## Summary
-
-A directive defines how the command is to be processed.
-
-## Description
-
-Directives are one of:
-
-* display - just display what we've found
-* validate - check the validity of the requested action
-* process - process the requested action
-
-## Abbreviation
-
-## Examples
-
-## Usage
-
-## Version
-
-0.1
-
-## Status
-
-DRAFT
-
----
-
-# Some terms specified - Now what?
-
-Ok - we've now created a glossary and three terms to go into the glossary. Here is what we'll do next.
-
->Note: This is changing - so will be somewhat abstrct
-
-We will run a small program called freddie_md.py to operate on this markdown file. When we run this program we 
-tell it not just the name of the file to process but also provide a directive on what to do. Currently we have the 
-choice of:
-
-1. Display - just parse the file, breaking it down into request blocks, and display what we find
-2. Validate - parse the file and validate if the commands can be processed - showing information about what we observe.
-3. Process - parse the request blocks and execute the commands - and produce a new output file to simplify further processing.
-
-# Great --> let's give it a try!