pyegeria 5.4.3.3__py3-none-any.whl → 5.4.4__py3-none-any.whl

md_processing/md_commands/solution_architect_commands.py

@@ -12,10 +12,11 @@ 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, set_element_prop_body, \
+    set_update_body, set_create_body
 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
+from pyegeria import body_slimmer, EgeriaTech, PyegeriaException, print_basic_exception
 
 load_commands('commands.json')
 
@@ -275,30 +276,15 @@ def process_blueprint_upsert_command(egeria_client: EgeriaTech, txt: str, direct
     attributes = parsed_output['attributes']
     description = attributes.get('Description', {}).get('value', None)
     display_name = attributes['Display Name'].get('value', None)
-    version_identifier = attributes.get('Version Identifier', {}).get('value', None)
-    effective_time = attributes.get('Effective Time', {}).get('value', None)
-    effective_from = attributes.get('Effective From', {}).get('value', None)
-    effective_to = attributes.get('Effective To', {}).get('value', None)
-    external_source_guid = attributes.get('External Source GUID', {}).get('value', None)
-    external_source_name = attributes.get('External Source Name', {}).get('value', None)
 
-    anchor_guid = attributes.get('Anchor ID', {}).get('guid', None)
-    parent_guid = attributes.get('Parent ID', {}).get('guid', None)
-    parent_relationship_type_name = attributes.get('Parent Relationship Type Name', {}).get('value', None)
-    parent_at_end1 = attributes.get('Parent at End1', {}).get('value', True)
 
-    anchor_scope_guid = attributes.get('Anchor Scope GUID', {}).get('value', None)
-    is_own_anchor = attributes.get('Is Own Anchor', {}).get('value', True)
-    if parent_guid is None:
-        is_own_anchor = True
 
-    additional_prop = attributes.get('Additional Properties', {}).get('value', None)
-    additional_properties = json.loads(additional_prop) if additional_prop is not None else None
-    extended_prop = attributes.get('Extended Properties', {}).get('value', None)
-    extended_properties = json.loads(extended_prop) if extended_prop is not None else None
+
     component_guids = attributes.get('Solution Components', {}).get('guid_list', None)
 
-    initial_status = "ACTIVE"
+    status = attributes.get('Status', {}).get('value', None)
+    if status is None:
+        status = "ACTIVE"
 
     replace_all_props = not attributes.get('Merge Update', {}).get('value', True)
 
@@ -313,6 +299,8 @@ def process_blueprint_upsert_command(egeria_client: EgeriaTech, txt: str, direct
         return valid
 
     elif directive == "process":
+        prop_body = set_element_prop_body(object_type, qualified_name, attributes)
+
         try:
             if object_action == "Update":
                 if not exists:
@@ -326,16 +314,19 @@ def process_blueprint_upsert_command(egeria_client: EgeriaTech, txt: str, direct
                     print(Markdown(
                         f"==> Validation of {command} completed successfully! Proceeding to apply the changes.\n"))
 
-                    body = body_slimmer({
-                        "class": "UpdateSolutionBlueprintRequestBody", "externalSourceGUID": external_source_guid,
-                        "externalSourceName": external_source_name, "effectiveTime": effective_time,
-                        "forLineage": False, "forDuplicateProcessing": False, "properties": {
-                            "class": "SolutionBlueprintProperties", "qualifiedName": qualified_name,
-                            "displayName": display_name, "description": description, "version": version_identifier,
-                            "additionalProperties": additional_properties, "extendedProperties": extended_properties,
-                            "effectiveFrom": effective_from, "effectiveTo": effective_to
-                            }
-                        })
+                    body = set_update_body(object_type, attributes)
+                    body['properties'] = prop_body
+                    egeria_client.update_solution_blueprint(guid, body)
+                    if status:
+                        egeria_client.update_solution_element_status(guid, status)
+
+                    msg = f"Updated  {object_type} `{display_name}` with GUID {guid}\n\n___"
+                    update_element_dictionary(qualified_name, {
+                        'guid': guid, 'display_name': display_name
+                    })
+                    logger.info(msg)
+                    logger.success(msg)
+                    return egeria_client.find_solution_blueprints(qualified_name, output_format='MD')
 
                 egeria_client.update_solution_blueprint(guid, body, replace_all_props)
                 logger.success(f"==> Updated  {object_type} `{display_name}` with GUID {guid}\n\n")
@@ -363,32 +354,8 @@ def process_blueprint_upsert_command(egeria_client: EgeriaTech, txt: str, direct
                         return
 
                     else:
-                        body = {
-                        "class": "NewSolutionBlueprintRequestBody",
-                        "externalSourceGUID": external_source_guid,
-                        "externalSourceName": external_source_name,
-                        "forLineage": False,
-                        "forDuplicateProcessing": False,
-                        "effectiveTime": effective_time,
-                        "anchorGUID": anchor_guid,
-                        "isOwnAnchor": is_own_anchor,
-                        "anchorScopeGUID": anchor_scope_guid,
-                        "parentGUID": parent_guid,
-                        "parentRelationshipTypeName": parent_relationship_type_name,
-                        "parentAtEnd1": parent_at_end1,
-                        "properties": {
-                            "class": "SolutionBlueprintProperties",
-                            "effectiveFrom": effective_from,
-                            "effectiveTo": effective_to,  # "typeName": type_name,
-                            "extendedProperties": extended_properties,
-                            "qualifiedName": qualified_name,
-                            "additionalProperties": additional_properties,
-                            "displayName": display_name,
-                            "description": description,
-                            "versionIdentifier": version_identifier
-                            },
-                        "initialStatus": initial_status,
-                        }
+                        body = set_create_body(object_type,attributes)
+                        body['properties'] = prop_body
                         guid = egeria_client.create_solution_blueprint(body)
                 except Exception as e:
                     print(f"Unexpected error: {e}, {type(valid)}, {valid}")
@@ -406,8 +373,8 @@ def process_blueprint_upsert_command(egeria_client: EgeriaTech, txt: str, direct
                     logger.error(msg)
                     return None
 
-        except Exception as e:
-            print("why did I get here")
+        except PyegeriaException as e:
+            print_basic_exception(e)
             logger.error(f"Error performing {command}: {e}")
             return None
     else:

md_processing/md_processing_utils/common_md_utils.py

@@ -240,6 +240,14 @@ def set_find_body(object_type: str, attributes: dict)->dict:
 
 
 def set_create_body(object_type: str, attributes: dict)->dict:
+    """
+    Build the OUTER request body for a create action (NewElementRequestBody).
+
+    Notes on two-layer convention:
+    - Outer layer (this function): action wrapper with metadata like externalSource*, effectiveTime, anchor/parent hints, and an empty "properties" field.
+    - Inner layer: an element-type-specific Properties structure built by set_element_prop_body, set_product_body, set_data_field_body, etc.
+    Callers should build the inner body separately with the appropriate helper and then assign it to body["properties"].
+    """
     prop_name = object_type.replace(" ", "")
     body = {
         "class": "NewElementRequestBody",
@@ -266,6 +274,13 @@ def set_create_body(object_type: str, attributes: dict)->dict:
 
 
 def set_update_body(object_type: str, attributes: dict)->dict:
+    """
+    Build the OUTER request body for an update action (UpdateElementRequestBody).
+
+    Two-layer convention:
+    - Outer layer (this function) provides action metadata and an empty "properties" slot.
+    - Inner layer must be constructed via element-specific helpers (e.g., set_element_prop_body) and assigned to the returned dict's "properties" key by the caller before invoking the client.
+    """
     return {
       "class" : "UpdateElementRequestBody",
       "externalSourceGUID": attributes.get('External Source GUID', {}).get('guid', None),
@@ -292,6 +307,16 @@ def set_rel_prop_body(object_type: str, attributes: dict)->dict:
         }
 
 def set_element_prop_body(object_type: str, qualified_name: str, attributes: dict)->dict:
+    """
+    Build the INNER element-specific Properties body to be placed under the outer body's "properties" key.
+
+    This returns the typed properties structure (e.g., "ReferenceableProperties" subtypes) appropriate for the object_type.
+    Usage example:
+    - outer = set_create_body(object_type, attributes)
+    - props = set_element_prop_body(object_type, qualified_name, attributes)
+    - outer["properties"] = props
+    - client.create_xxx(outer)
+    """
     prop_name = object_type.replace(" ", "")
     display_name = attributes.get('Display Name', {}).get('value', None)
 
@@ -323,7 +348,21 @@ def set_product_body(object_type: str, qualified_name: str, attributes: dict)->d
     prop_bod["nextVersion"] = attributes.get('Next Version Date', {}).get('value', [])
     return prop_bod
 
-
+def set_data_field_body(object_type: str, qualified_name: str, attributes: dict)->dict:
+    prop_bod = set_element_prop_body(object_type, qualified_name, attributes)
+    prop_bod["namespace"] = attributes.get('Namespace', {}).get('value', None)
+    prop_bod["aliases"] = attributes.get('Aliases', {}).get('value', [])
+    prop_bod["namePatterns"] = attributes.get('Name Patterns', {}).get('value', [])
+    prop_bod["defaultValue"] = attributes.get('Default Value', {}).get('value', None)
+    prop_bod["isNullable"] = attributes.get('Is Nullable', {}).get('value', None)
+    prop_bod["dataType"] = attributes.get('Data Type', {}).get('value', None)
+    prop_bod["units"] = attributes.get('Units', {}).get('value', None)
+    prop_bod["minimumLength"] = attributes.get('Minimum Length', {}).get('value', None)
+    prop_bod["length"] = attributes.get('Length', {}).get('value', None)
+    prop_bod["precision"] = attributes.get('Precision', {}).get('value', None)
+    prop_bod["orderedValues"] = attributes.get('Ordered Values', {}).get('value', [])
+    prop_bod["sortOrder"] = attributes.get('Sort Order', {}).get('value', None)
+    return prop_bod
 
 def set_update_status_body(object_type: str, attributes: dict)->dict:
     return {
@@ -394,6 +433,11 @@ def update_gov_body_for_type(object_type: str, body: dict, attributes: dict) ->
 
 
 def set_rel_request_body(object_type: str, attributes: dict)->dict:
+    """
+    Build the OUTER request body for creating a relationship (NewRelationshipRequestBody).
+    The inner relationship properties must be assigned to the returned dict under the "properties" key,
+    commonly via set_rel_prop_body or set_rel_request_body_for_type.
+    """
     return {
       "class" : "NewRelationshipRequestBody",
       "externalSourceGUID": attributes.get('External Source GUID', {}).get('guid', None),
@@ -416,6 +460,11 @@ def set_peer_gov_def_request_body(object_type: str, attributes: dict)->dict:
     return rel_body
 
 def set_rel_request_body_for_type(object_type: str, attributes: dict)->dict:
+    """
+    Convenience helper that builds both layers (outer + inner) for a relationship of a known type.
+    It creates the outer NewRelationshipRequestBody via set_rel_request_body and fills rel_body["properties"]
+    with a typed properties structure under the "class" of f"{object_type}Properties".
+    """
     rel_body = set_rel_request_body(object_type, attributes)
     # class_prop = camel_to_title_case(object_type) + "Properties"
     class_prop = f"{object_type}Properties"

md_processing/md_processing_utils/debug_log

@@ -1,3 +1 @@
-D 2025-08-27T07:09:25.357601-0500 | INFO | create_help_terms | 162 | Help documentation saved to ././dr-egeria-help-2025-08-27T07:09:25.md | {}
-D 2025-08-27T10:11:41.452446-0500 | INFO | create_help_terms | 184 | Help documentation saved to ././dr-egeria-help-2025-08-27T10:11:41.md | {}
-D 2025-08-27T10:33:31.756212-0500 | INFO | create_help_terms | 184 | Help documentation saved to ././dr-egeria-help-2025-08-27T10:33:31.md | {}
+D 2025-09-09T11:10:03.787382-0500 | INFO | create_help_terms | 184 | Help documentation saved to ././dr-egeria-help-2025-09-09T11:10:03.md | {}