pyegeria 5.4.0.dev11__py3-none-any.whl → 5.4.0.dev12__py3-none-any.whl

md_processing/md_commands/solution_architect_commands.py

@@ -27,94 +27,182 @@ 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,
+                               replace_all_props:bool):
+    if replace_all_props:
+        rel_el_list = egeria_client._get_supply_chain_rel_elements(guid)
+        if rel_el_list is None:
+            logger.warning("Unexpected -> the list was None - assigning empty list")
+            rel_el_list = {}
+
+        as_is_parent_guids = set(rel_el_list.get("parent_guids", []))
+
+        to_be_parent_guids = set(in_supply_chain_guids) if in_supply_chain_guids is not None else set()
+
+        logger.trace(
+            f"as_is_parent supply chains: {list(as_is_parent_guids)} to_be_parent supply chains: {list(to_be_parent_guids)}")
+
+
+        parent_guids_to_remove =  as_is_parent_guids - to_be_parent_guids
+        logger.trace(f"parent_guids_to_remove: {list(parent_guids_to_remove)}")
+        if len(parent_guids_to_remove) > 0:
+            for parent_guid in parent_guids_to_remove:
+                egeria_client.decompose_info_supply_chains(parent_guid, guid,  None)
+                msg = f"Removed `{display_name}` from supply chain parent `{parent_guid}`"
+                logger.trace(msg)
+
+        parent_guids_to_add = to_be_parent_guids - as_is_parent_guids
+        logger.trace(f"parent supply chains_to_add: {list(parent_guids_to_add)}")
+        if len(parent_guids_to_add) > 0:
+            for parent_guid in parent_guids_to_add:
+                egeria_client.compose_info_supply_chains(parent_guid, guid, None)
+                msg = f"Added `{display_name}` to supply chain parent `{parent_guid}`"
+                logger.trace(msg)
+
+    else:  # merge - add supply chain to parents
+        if in_supply_chain_guids:
+            for parent_guid in in_supply_chain_guids:
+                egeria_client.compose_info_supply_chains(parent_guid, guid, None)
+                msg = f"Added `{display_name}` to supply chain `{parent_guid}`"
+                logger.trace(msg)
+
+
 
 @logger.catch
-def sync_component_related_elements(egeria_client: EgeriaTech, object_type: str, sub_component_guids: list,
+def sync_component_related_elements(egeria_client: EgeriaTech, object_type: str,
+                                    supply_chain_guids: list, parent_component_guids: list,
                                     actor_guids: list, in_blueprint_guids: list, guid: str, qualified_name: str,
-                                    display_name: str, replace_all_props: bool = True) -> None:
+                                    display_name: str, merge_update: bool = True) -> None:
     """Sync a components related elements.
 
     """
-    if replace_all_props:
+    if not merge_update:
         rel_el_list = egeria_client.get_component_related_elements(guid)
         # should I throw an exception if empty?
-        as_is_sub_components = set(rel_el_list.get("sub_component_guids", []))
+
         as_is_actors = set(rel_el_list.get("actor_guids", []))
         as_is_blueprints = set(rel_el_list.get("blueprint_guids", []))
+        as_is_parent_components = set(rel_el_list.get("parent_component_guids", []))
+        as_is_supply_chains = set(rel_el_list.get("supply_chain_guids", []))
+
 
-        to_be_sub_components = set(sub_component_guids) if sub_component_guids is not None else set()
         to_be_actors = set(actor_guids) if actor_guids is not None else set()
         to_be_blueprints = set(in_blueprint_guids) if in_blueprint_guids is not None else set()
+        to_be_parent_components = set(parent_component_guids) if parent_component_guids is not None else set()
+        to_be_supply_chains = set(supply_chain_guids) if supply_chain_guids is not None else set()
+
 
         logger.trace(
-            f"as_is_sub_components: {list(as_is_sub_components)} to_be_sub_components: {list(to_be_sub_components)}")
+            f"as_is_sub_components: {list(as_is_parent_components)} to_be_sub_components: {list(to_be_parent_components)}")
         logger.trace(f"as_is_actors: {list(as_is_actors)} to_be_actors: {list(to_be_actors)}")
         logger.trace(f"as_is_blueprints: {list(as_is_blueprints)} to_be_blueprints: {list(to_be_blueprints)}")
 
-        sub_components_to_remove = as_is_sub_components - to_be_sub_components
-        logger.trace(f"sub_components_to_remove: {list(sub_components_to_remove)}")
-        if len(sub_components_to_remove) > 0:
-            for ds in sub_components_to_remove:
-                egeria_client.detach_sub_component(guid, ds, None)
-                msg = f"Removed `{ds}` from component `{display_name}`"
+        parent_components_to_remove = as_is_parent_components - to_be_parent_components
+        logger.trace(f"sub_components_to_remove: {list(parent_components_to_remove)}")
+        if len(parent_components_to_remove) > 0:
+            for ds in parent_components_to_remove:
+                egeria_client.detach_sub_component(ds, guid, None)
+                msg = f"Removed `{display_name}` from component `{ds}`"
                 logger.trace(msg)
-        sub_components_to_add = to_be_sub_components - as_is_sub_components
-        logger.trace(f"sub_components_to_add: {list(sub_components_to_add)}")
-        if len(sub_components_to_add) > 0:
-            for ds in sub_components_to_add:
-                egeria_client.link_subcomponent(guid, ds, None)
-                msg = f"Added `{ds}` to component `{display_name}`"
+
+        parent_components_to_add = to_be_parent_components - as_is_parent_components
+        logger.trace(f"parent_components_to_add: {list(parent_components_to_add)}")
+        if len(parent_components_to_add) > 0:
+            for ds in parent_components_to_add:
+                egeria_client.link_subcomponent(ds, guid, None)
+                msg = f"Added `{display_name}` to component `{ds}`"
+                logger.trace(msg)
+
+        blueprints_to_remove = as_is_blueprints - to_be_blueprints
+        logger.trace(f"blueprints_to_remove: {list(blueprints_to_remove)}")
+        if len(blueprints_to_remove) > 0:
+            for bp in blueprints_to_remove:
+                egeria_client.detach_solution_component_from_blueprint(bp, guid, None)
+                msg = f"Removed `{display_name}` from blueprintt `{bp}`"
+                logger.trace(msg)
+
+        blueprints_to_add = to_be_blueprints - as_is_blueprints
+        logger.trace(f"blueprints_to_add: {list(blueprints_to_add)}")
+        if len(blueprints_to_add) > 0:
+            for bp in blueprints_to_add:
+                egeria_client.link_solution_component_to_blueprint(bp, guid, None)
+                msg = f"Added `{display_name}` to component `{bp}`"
                 logger.trace(msg)
 
+
+
         actors_to_remove = to_be_actors - as_is_actors
         logger.trace(f"actors_to_remove: {list(actors_to_remove)}")
         if len(actors_to_remove) > 0:
             for actor in actors_to_remove:
-                egeria_client.detach_component_from_role(actor, guid, None)
+                egeria_client.detach_component_actore(actor, guid, None)
                 msg = f"Removed actor `{actor}` from component `{display_name}`"
                 logger.trace(msg)
+
         actors_to_add = to_be_actors - as_is_actors
         logger.trace(f"actors_to_add: {list(actors_to_add)}")
         if len(actors_to_add) > 0:
             for actor in actors_to_add:
-                egeria_client.link_component_to_role(actor, guid, None)
+                egeria_client.link_component_to_actor(actor, guid, None)
                 msg = f"Added `{display_name}` to role `{actor}`"
                 logger.trace(msg)
 
-        blueprints_to_remove = as_is_blueprints - to_be_blueprints
-        logger.trace(f"blueprints_to_remove: {list(blueprints_to_remove)}")
-        if len(blueprints_to_remove) > 0:
-            for bp in blueprints_to_remove:
-                egeria_client.detach_solution_component_from_blueprint(bp, guid)
-                msg = f"Removed `{bp}` from `{display_name}`"
+        supply_chains_to_remove = as_is_supply_chains - to_be_supply_chains
+        logger.trace(f"supply_chains_to_remove: {list(supply_chains_to_remove)}")
+        if len(supply_chains_to_remove) > 0:
+            for isc in supply_chains_to_remove:
+                egeria_client.detach_design_from_implementation(isc, guid)
+                msg = f"Removed `{isc}` from `{display_name}`"
                 logger.trace(msg)
-        blueprints_to_add = to_be_blueprints - as_is_blueprints
-        logger.trace(f"blueprints_to_add: {list(blueprints_to_add)}")
-        if len(blueprints_to_add) > 0:
-            for bp in blueprints_to_add:
-                egeria_client.link_solution_component_to_blueprint(bp, guid)
-                msg = f"Added `{bp}` to`{display_name}`"
+        supply_chains_to_add = to_be_supply_chains - as_is_supply_chains
+        logger.trace(f"supply_chains_to_add: {list(supply_chains_to_add)}")
+        if len(supply_chains_to_add) > 0:
+            body = {
+                "class": "RelationshipRequestBody",
+                "properties": {
+                    "class": "ImplementedByProperties",
+                    "description": "a blank description to satisfy the Egeria gods"
+                    }
+                }
+            for isc in supply_chains_to_add:
+                egeria_client.link_design_to_implementation(isc, guid, body)
+                msg = f"Added `{isc}` to`{display_name}`"
                 logger.trace(msg)
-        logger.info(f"Replaced the related elements in `{display_name}`")
+            logger.info(f"Replaced the related elements in `{display_name}`")
 
     else:  # merge - add field to related elements
-        if sub_component_guids:
-            for comp in sub_component_guids:
+        if parent_component_guids:
+            for comp in parent_component_guids:
                 egeria_client.link_subcomponent(guid, comp, None)
-            msg = f"Added `{sub_component_guids}` to `{display_name}`"
-            logger.trace(msg)
+                msg = f"Added `{parent_component_guids}` to `{display_name}`"
+                logger.trace(msg)
 
         if actor_guids:
             for actor in actor_guids:
-                egeria_client.link_component_to_role(actor, guid, None)
-            msg = f"Added `{actor_guids}` to `{display_name}`"
-            logger.trace(msg)
+                egeria_client.link_component_to_actor(actor, guid, None)
+                msg = f"Added `{actor_guids}` to `{display_name}`"
+                logger.trace(msg)
 
         if in_blueprint_guids:
             for bp in in_blueprint_guids:
                 egeria_client.link_solution_component_to_blueprint(bp, guid, None)
-            msg = f"Added `{in_blueprint_guids}` to `{display_name}`"
-            logger.trace(msg)
+                msg = f"Added `{in_blueprint_guids}` to `{display_name}`"
+                logger.trace(msg)
+
+        if supply_chain_guids:
+            body = {
+                "class": "RelationshipRequestBody",
+                "properties": {
+                    "class": "ImplementedByProperties",
+                    "description": "a blank description to satisfy the Egeria gods"
+                }
+            }
+            for isc in supply_chain_guids:
+                egeria_client.link_design_to_implementation(isc, guid, body)
+                msg = f"Added `{display_name}` to `{isc}`"
+                logger.trace(msg)
+
         logger.info(f"Merged related elements in `{display_name}`")
 
 
@@ -215,6 +303,8 @@ def process_blueprint_upsert_command(egeria_client: EgeriaTech, txt: str, direct
     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"
+
     replace_all_props = not attributes.get('Merge Update', {}).get('value', True)
 
     if directive == "display":
@@ -264,33 +354,51 @@ def process_blueprint_upsert_command(egeria_client: EgeriaTech, txt: str, direct
 
 
             elif object_action == "Create":
-                if valid is False and exists:
-                    msg = (f"  Data Specification `{display_name}` already exists and result document updated changing "
-                           f"`Create` to `Update` in processed output\n\n___")
-                    logger.error(msg)
-                    return update_a_command(txt, object_action, object_type, qualified_name, guid)
+                print(f"valid: {valid}, type: {type(valid)}")
+                try:
+                    if valid is False and exists:
+                        msg = (f"  Data Specification `{display_name}` already exists and result document updated changing "
+                               f"`Create` to `Update` in processed output\n\n___")
+                        logger.error(msg)
+                        return update_a_command(txt, object_action, object_type, qualified_name, guid)
 
-                elif not valid:
-                    msg = (f"==>{object_type} `{display_name}` is not valid and can't be created")
-                    logger.error(msg)
-                    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, "version": version_identifier
+                    elif not valid:
+                        msg = (f"==>{object_type} `{display_name}` is not valid and can't be created")
+                        logger.error(msg)
+                        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,
                         }
-                    }
+                        guid = egeria_client.create_solution_blueprint(body)
+                except Exception as e:
+                    print(f"Unexpected error: {e}, {type(valid)}, {valid}")
+
 
-                guid = egeria_client.create_solution_blueprint(body)
                 if guid:
                     update_element_dictionary(qualified_name, {
                         'guid': guid, 'display_name': display_name
@@ -304,6 +412,7 @@ def process_blueprint_upsert_command(egeria_client: EgeriaTech, txt: str, direct
                     return None
 
         except Exception as e:
+            print("why did I get here")
             logger.error(f"Error performing {command}: {e}")
             return None
     else:
@@ -337,9 +446,30 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, txt: st
     logger.debug(json.dumps(parsed_output, indent=4))
 
     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)
+    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)
+    user_defined_status = attributes.get('User Defined Status', {}).get('value', None)
+    if initial_status != "OTHER":
+        user_defined_status = None
+
+    # sub_component_names = attributes.get('Solution SubComponents', {}).get('name_list', None)
+    # sub_component_guids = attributes.get('Solution SubComponents', {}).get('guid_list', None)
+    actor_names = attributes.get('Actors', {}).get('name_list', None)
+    actor_guids = attributes.get('Actors', {}).get('guid_list', None)
+    in_blueprint_names = attributes.get('In Solution Blueprints', {}).get('name_list', None)
+    in_blueprint_guids = attributes.get('In Solution Blueprints', {}).get('guid_list', None)
+    in_supply_chain_names = attributes.get('In Information Supply Chains', {}).get('name_list', None)
+    in_supply_chain_guids = attributes.get('In Information Supply Chains', {}).get('guid_list', None)
+    in_component_names = attributes.get('In Solution Components', {}).get('name_list', None)
+    in_component_guids = attributes.get('In Solution Components', {}).get('guid_list', None)
+    parent_component_guids = attributes.get('Parent Components', {}).get('guid_list', None)
+    parent_component_names = attributes.get('Parent Components', {}).get('name_list', 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)
@@ -349,6 +479,7 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, txt: st
     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_relationship_properties = attributes.get('Parent Relationship Properties', {}).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)
@@ -361,16 +492,9 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, txt: st
     extended_prop = attributes.get('Extended Properties', {}).get('value', None)
     extended_properties = json.loads(extended_prop) if extended_prop is not None else None
 
-    replace_all_props = not attributes.get('Merge Update', {}).get('value', True)
+    merge_update = attributes.get('Merge Update', {}).get('value', True)
+
 
-    solution_component_type = attributes.get('Solution Component Type', {}).get('value', None)
-    planned_deployed_impl_type = attributes.get('Planned Deployed Implementation Type', {}).get('value', None)
-    sub_component_names = attributes.get('Solution SubComponents', {}).get('name_list', None)
-    sub_component_guids = attributes.get('Solution SubComponents', {}).get('guid_list', None)
-    actor_names = attributes.get('Actors', {}).get('name_list', None)
-    actor_guids = attributes.get('Actors', {}).get('guid_list', None)
-    in_blueprint_names = attributes.get('Solution Blueprints', {}).get('name_list', None)
-    in_blueprint_guids = attributes.get('Solution Blueprints', {}).get('guid_list', None)
 
     if directive == "display":
 
@@ -398,27 +522,37 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, txt: st
                         f"==> Validation of {command} completed successfully! Proceeding to apply the changes.\n"))
 
                 body = body_slimmer({
-                    "class": "UpdateSolutionComponentRequestBody", "externalSourceGUID": external_source_guid,
-                    "externalSourceName": external_source_name, "effectiveTime": effective_time, "forLineage": False,
-                    "forDuplicateProcessing": False, "parentAtEnd1": parent_at_end1, "properties": {
-                        "class": "SolutionComponentProperties", "qualifiedName": qualified_name,
-                        "displayName": display_name, "description": description,
+                    "class": "UpdateElementRequestBody",
+                    "externalSourceGUID": external_source_guid,
+                    "externalSourceName": external_source_name,
+                    "effectiveTime": effective_time, "forLineage": False,
+                    "forDuplicateProcessing": False,
+                    "parentAtEnd1": parent_at_end1,
+                    "properties": {
+                        "class": "SolutionComponentProperties",
+                        "qualifiedName": qualified_name,
+                        "displayName": display_name,
+                        "description": description,
                         "solutionComponentType": solution_component_type,
                         "plannedDeployedImplementationType": planned_deployed_impl_type,
-                        "additionalProperties": additional_properties, "extendedProperties": extended_properties,
-                        "effectiveFrom": effective_from, "effectiveTo": effective_to
+                        "additionalProperties": additional_properties,
+                        "extendedProperties": extended_properties,
+                        "effectiveFrom": effective_from,
+                        "effectiveTo": effective_to
                         }
                     })
 
-                egeria_client.update_solution_component(guid, body, replace_all_props)
+                egeria_client.update_solution_component(guid, body, not merge_update)
                 logger.success(f"==>Updated  {object_type} `{display_name}` with GUID {guid}\n")
                 update_element_dictionary(qualified_name, {
                     'guid': guid, 'display_name': display_name
                     })
                 # Sync Parent Components and Blueprints
-                sync_component_related_elements(egeria_client, object_type, sub_component_guids, actor_guids,
-                                                in_blueprint_guids, guid, qualified_name, display_name,
-                                                replace_all_props)
+                sync_component_related_elements(egeria_client, object_type ,
+                                                in_supply_chain_guids,parent_component_guids,actor_guids,
+                                                in_blueprint_guids, guid, qualified_name, 
+                                                display_name,
+                                                merge_update)
                 logger.success(f"==>Updated  {object_type} `{display_name}` with related elements")
                 return egeria_client.get_solution_component_by_guid(guid, output_format='MD')
 
@@ -437,21 +571,34 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, txt: st
 
                 else:
                     body = body_slimmer({
-                        "class": "NewSolutionComponentRequestBody", "externalSourceGUID": external_source_guid,
-                        "externalSourceName": external_source_name, "forLineage": False,
-                        "forDuplicateProcessing": False, "effectiveTime": effective_time, "anchorGUID": anchor_guid,
-                        "isOwnAnchor": True, "anchorScopeGUID": anchor_scope_guid, "parentGUID": parent_guid,
-                        "parentRelationshipTypeName": parent_relationship_type_name, "parentAtEnd1": parent_at_end1,
+                        "class": "NewSolutionElementRequestBody",
+                        "anchorGUID": anchor_guid,
+                        "isOwnAnchor": is_own_anchor,
+                        "parentGUID": parent_guid,
+                        "parentRelationshipTypeName": parent_relationship_type_name,
+                        "parentRelationshipProperties": parent_relationship_properties,
+                        "parentAtEnd1": parent_at_end1,
                         "properties": {
-                            "class": "SolutionComponentProperties", "effectiveFrom": effective_from,
-                            "effectiveTo": effective_to, "extendedProperties": extended_properties,
-                            "qualifiedName": qualified_name, "additionalProperties": additional_properties,
-                            "displayName": display_name, "description": description,
+                            "class": "SolutionComponentProperties",
+                            "qualifiedName": qualified_name,
+                            "displayName": display_name,
+                            "description": description,
                             "solutionComponentType": solution_component_type,
-                            "plannedDeployedImplementationType": planned_deployed_impl_type
-
-                            }
-                        })
+                            "versionIdentifier" : version_identifier,
+                            "plannedDeployedImplementationType": planned_deployed_impl_type,
+                            "userDefinedStatus" : user_defined_status,
+                            "additionalProperties": additional_properties,
+                            "extendedProperties": extended_properties,
+                            "effectiveFrom": effective_from,
+                            "effectiveTo": effective_to
+                        },
+                        "initialStatus": initial_status,
+                        "externalSourceGUID": external_source_guid,
+                        "externalSourceName": external_source_name,
+                        "effectiveTime": effective_time,
+                        "forLineage": False,
+                        "forDuplicateProcessing": False
+                    })
 
                     guid = egeria_client.create_solution_component(body)
                     if guid:
@@ -460,22 +607,28 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, txt: st
                             })
                         msg = f"Created Element `{display_name}` with GUID {guid}\n\n___"
                         logger.success(msg)
-                        if sub_component_guids:
-                            for comp in sub_component_guids:
-                                egeria_client.link_subcomponent(guid, comp, None)
-                            msg = f"Added `{sub_component_guids}` to `{display_name}`"
+                        if in_component_guids:
+                            for comp in in_component_guids:
+                                egeria_client.link_subcomponent(comp, guid, None)
+                            msg = f"Added to parent components `{in_component_names}` "
                             logger.trace(msg)
 
                         if actor_guids:
                             for actor in actor_guids:
-                                egeria_client.link_component_to_role(actor, guid, None)
+                                egeria_client.link_component_to_actor(actor, guid, None)
                             msg = f"Added `{actor_guids}` to `{display_name}`"
                             logger.trace(msg)
 
                         if in_blueprint_guids:
                             for bp in in_blueprint_guids:
                                 egeria_client.link_solution_component_to_blueprint(bp, guid, None)
-                            msg = f"Added `{in_blueprint_guids}` to `{display_name}`"
+                            msg = f"Added  `{display_name}`to blueprints `{in_blueprint_names}`"
+                            logger.trace(msg)
+
+                        if in_supply_chain_guids:
+                            for isc in in_supply_chain_guids:
+                                egeria_client.link_design_to_implementation(isc, guid, None)
+                            msg = f"Added  `{display_name}`to supply chain `{in_supply_chain_names}`"
                             logger.trace(msg)
 
                         return egeria_client.get_solution_component_by_guid(guid, output_format='MD')
@@ -492,12 +645,10 @@ def process_solution_component_upsert_command(egeria_client: EgeriaTech, txt: st
 
 
 @logger.catch
-def process_information_supply_chain_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") \
-        -> \
-        Optional[str]:
+def process_component_link_unlink_command(egeria_client: EgeriaTech, txt: str,
+                                                         directive: str = "display") -> Optional[str]:
     """
-    Processes a solution blueprint create or update object_action by extracting key attributes such as
-    blueprint name, description, and usage from the given text.
+    Processes a link or unlink command to wire solution components.
 
     :param txt: A string representing the input cell to be processed for
         extracting blueprint-related attributes.
@@ -506,49 +657,35 @@ def process_information_supply_chain_upsert_command(egeria_client: EgeriaTech, t
     """
     command, object_type, object_action = extract_command_plus(txt)
 
-    parsed_output = parse_upsert_command(egeria_client, object_type, object_action, txt, directive)
-
-    valid = parsed_output['valid']
-    exists = parsed_output['exists']
-
-    qualified_name = parsed_output.get('qualified_name', None)
-    guid = parsed_output.get('guid', None)
+    parsed_output = parse_view_command(egeria_client, object_type, object_action, txt, directive)
 
     print(Markdown(parsed_output['display']))
 
     logger.debug(json.dumps(parsed_output, indent=4))
 
     attributes = parsed_output['attributes']
+
+    component1 = attributes.get('Component1', {}).get('guid', None)
+    component2 = attributes.get('Component2', {}).get('guid', None)
+    label = attributes.get('Wire Label', {}).get('value', None)
     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)
+
+    valid = parsed_output['valid']
+    exists = component1 is not None and  component2 is not 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
+    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)
 
     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
 
-    scope = attributes.get('Scope', {}).get('value', None)
-    purposes = attributes.get('Purposes', {}).get('value', None)
-    segment_guids = attributes.get('Information Supply Chain Segments', {}).get('guid_list', None)
-
-    replace_all_props = not attributes.get('Merge Update', {}).get('value', True)
-
     if directive == "display":
 
         return None
@@ -561,12 +698,13 @@ def process_information_supply_chain_upsert_command(egeria_client: EgeriaTech, t
 
     elif directive == "process":
         try:
-            if object_action == "Update":
+            if object_action == "Unlink":
                 if not exists:
-                    msg = (f" Element `{display_name}` does not exist! Updating result document with Create "
+                    msg = (f" Link `{label}` does not exist! Updating result document with Link "
                            f"object_action\n")
                     logger.error(msg)
-                    return update_a_command(txt, object_action, object_type, qualified_name, guid)
+                    out = parsed_output['display'].replace('Link', 'Detach', 1)
+                    return out
                 elif not valid:
                     return None
                 else:
@@ -574,68 +712,53 @@ def process_information_supply_chain_upsert_command(egeria_client: EgeriaTech, t
                         f"==> Validation of {command} completed successfully! Proceeding to apply the changes.\n"))
 
                     body = body_slimmer({
-                        "class": "UpdateInformationSupplyChainRequestBody", "externalSourceGUID": external_source_guid,
-                        "externalSourceName": external_source_name, "effectiveTime": effective_time,
-                        "forLineage": False, "forDuplicateProcessing": False, "properties": {
-                            "class": "InformationSupplyChainProperties", "effectiveFrom": effective_from,
-                            "effectiveTo": effective_to, "extendedProperties": extended_properties,
-                            "qualifiedName": qualified_name, "additionalProperties": additional_properties,
-                            "displayName": display_name, "description": description, "scope": scope,
-                            "purposes": purposes, "version": version_identifier
-                            }
+                        "class": "MetadataSourceRequestBody",
+                        "externalSourceGUID": external_source_guid,
+                        "externalSourceName": external_source_name,
+                        "effectiveTime": effective_time,
+                        "forLineage": False,
+                        "forDuplicateProcessing": False
                         })
 
-                egeria_client.update_info_supply_chain(guid, body, replace_all_props)
-                logger.success(f"==> Updated  {object_type} `{display_name}` with GUID {guid}\n\n")
-                update_element_dictionary(qualified_name, {
-                    'guid': guid, 'display_name': display_name
-                    })
-                # sync_blueprint_related_elements(egeria_client,object_type, segment_guids, guid, qualified_name,
-                # display_name, replace_all_props)
-                # logger.success(f"===> Updated {object_type} `{display_name}` related elements\n\n")
-                return egeria_client.get_info_supply_chain_by_guid(guid, output_format='MD')
+                egeria_client.detach_solution_linking_wire(component1, component2, body)
 
+                logger.success(f"===> Detached segment with {label} from `{component1}`to {component2}\n")
+                out = parsed_output['display'].replace('Unlink', 'Link', 1)
 
-            elif object_action == "Create":
+                return (out)
+
+
+            elif object_action == "Link":
                 if valid is False and exists:
-                    msg = (
-                        f"-->  Data Specification `{display_name}` already exists and result document updated changing "
-                        f"`Create` to `Update` in processed output\n")
+                    msg = (f"-->  Link called `{label}` already exists and result document updated changing "
+                           f"`Link` to `Detach` in processed output\n")
                     logger.error(msg)
-                    return update_a_command(txt, object_action, object_type, qualified_name, guid)
 
                 elif valid is False:
-                    msg = f"==>{object_type} `{display_name}` is not valid and can't be created"
+                    msg = f"==>{object_type} Link with label `{label}` is not valid and can't be created"
                     logger.error(msg)
                     return
                 else:
                     body = {
-                        "class": "NewInformationSupplyChainRequestBody", "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,
+                        "class": "RelationshipRequestBody",
+                        "effectiveTime": effective_time,
+                        "forLineage": False,
+                        "forDuplicateProcessing": False,
                         "properties": {
-                            "class": "InformationSupplyChainProperties", "effectiveFrom": effective_from,
-                            "effectiveTo": effective_to, "extendedProperties": extended_properties,
-                            "qualifiedName": qualified_name, "additionalProperties": additional_properties,
-                            "displayName": display_name, "description": description, "scope": scope,
-                            "purposes": purposes, "version": version_identifier
+                            "class": "SolutionLinkingWireProperties",
+                            "label": label,
+                            "description": description,
+                            "effectiveFrom": effective_from,
+                            "effectiveTo": effective_to
                             }
                         }
 
-                    guid = egeria_client.create_info_supply_chain(body)
-                    if guid:
-                        update_element_dictionary(qualified_name, {
-                            'guid': guid, 'display_name': display_name
-                            })
-                        msg = f"==>Created Element `{display_name}` with GUID {guid}\n"
-                        logger.success(msg)
-                        return egeria_client.get_info_supply_chain_by_guid(guid, output_format='MD')
-                    else:
-                        msg = f"==>Failed to create element `{display_name}` with GUID {guid}\n"
-                        logger.error(msg)
-                        return None
+                    egeria_client.link_solution_linking_wire(component1, component2, None)
+                    msg = f"==>Created {object_type} link named `{label}`\n"
+                    logger.success(msg)
+                    out = parsed_output['display'].replace('Link', 'Detach', 1)
+                    return out
+
 
         except Exception as e:
             logger.error(f"Error performing {command}: {e}")
@@ -644,9 +767,11 @@ def process_information_supply_chain_upsert_command(egeria_client: EgeriaTech, t
         return None
 
 
+
 @logger.catch
-def process_information_supply_chain_segment_upsert_command(egeria_client: EgeriaTech, txt: str,
-                                                            directive: str = "display") -> Optional[str]:
+def process_information_supply_chain_upsert_command(egeria_client: EgeriaTech, txt: str, directive: str = "display") \
+        -> \
+        Optional[str]:
     """
     Processes a solution blueprint create or update object_action by extracting key attributes such as
     blueprint name, description, and usage from the given text.
@@ -689,17 +814,16 @@ def process_information_supply_chain_segment_upsert_command(egeria_client: Egeri
     is_own_anchor = attributes.get('Is Own Anchor', {}).get('value', True)
     if parent_guid is None:
         is_own_anchor = True
-
+    nested_supply_chain_guids = attributes.get('Nested Supply Chain', {}).get('guids', None)
     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
 
     scope = attributes.get('Scope', {}).get('value', None)
-    integration_style = attributes.get('Integration Style', {}).get('value', None)
-    volumetrics = attributes.get('Estimated Volumetrics', {}).get('value', None)
-    info_supply_chain = attributes.get('Information Supply Chain', {}).get('value', None)
-    info_supply_chain_guid = attributes.get('Information Supply Chain', {}).get('guid', None)
+    purposes = attributes.get('Purposes', {}).get('value', None)
+    in_supply_chain_guids = attributes.get('In Information Supply Chain', {}).get('guid_list', None)
+
     replace_all_props = not attributes.get('Merge Update', {}).get('value', True)
 
     if directive == "display":
@@ -727,28 +851,31 @@ def process_information_supply_chain_segment_upsert_command(egeria_client: Egeri
                         f"==> Validation of {command} completed successfully! Proceeding to apply the changes.\n"))
 
                     body = body_slimmer({
-                        "class": "UpdateInformationSupplyChainSegmentRequestBody",
-                        "externalSourceGUID": external_source_guid, "externalSourceName": external_source_name,
-                        "effectiveTime": effective_time, "forLineage": False, "forDuplicateProcessing": False,
+                        "class": "UpdateElementRequestBody",
+                        "externalSourceGUID": external_source_guid,
+                        "externalSourceName": external_source_name,
+                        "effectiveTime": effective_time,
+                        "forLineage": False,
+                        "forDuplicateProcessing": False,
                         "properties": {
-                            "class": "InformationSupplyChainSegmentProperties", "effectiveFrom": effective_from,
+                            "class": "InformationSupplyChainProperties", "effectiveFrom": effective_from,
                             "effectiveTo": effective_to, "extendedProperties": extended_properties,
                             "qualifiedName": qualified_name, "additionalProperties": additional_properties,
                             "displayName": display_name, "description": description, "scope": scope,
-                            "integrationStyle": integration_style, "estimatedVolumetrics": volumetrics,
-                            "version": version_identifier
+                            "purposes": purposes, "version": version_identifier
                             }
                         })
 
-                egeria_client.update_info_supply_chain_segment(info_supply_chain_guid, body, replace_all_props)
+                egeria_client.update_info_supply_chain(guid, body, replace_all_props)
+
+                sync_chain_related_elements(egeria_client, guid, in_supply_chain_guids, display_name, replace_all_props)
+                logger.success(f"==> Updated  {object_type} `{display_name}` with GUID {guid}\n\n")
                 update_element_dictionary(qualified_name, {
                     'guid': guid, 'display_name': display_name
                     })
-                logger.success(f"===> Updated {object_type} `{display_name}` with GUID {guid}\n")
-                # sync_blueprint_related_elements(egeria_client,object_type, segment_guids, guid, qualified_name,
-                # display_name, replace_all_props)
+
                 # logger.success(f"===> Updated {object_type} `{display_name}` related elements\n\n")
-                return egeria_client.get_info_supply_chain_segment_by_guid(guid, info_supply_chain_guid)
+                return egeria_client.get_info_supply_chain_by_guid(guid, output_format='MD')
 
 
             elif object_action == "Create":
@@ -765,29 +892,45 @@ def process_information_supply_chain_segment_upsert_command(egeria_client: Egeri
                     return
                 else:
                     body = {
-                        "class": "NewInformationSupplyChainSegmentRequestBody",
-                        "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": "InformationSupplyChainSegmentProperties", "effectiveFrom": effective_from,
-                            "effectiveTo": effective_to, "extendedProperties": extended_properties,
-                            "qualifiedName": qualified_name, "additionalProperties": additional_properties,
-                            "displayName": display_name, "description": description, "scope": scope,
-                            "integrationStyle": integration_style, "estimatedVolumetrics": volumetrics,
+                        "class": "NewElementRequestBody",
+                        "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": "InformationSupplyChainProperties",
+                            "effectiveFrom": effective_from,
+                            "effectiveTo": effective_to,
+                            "extendedProperties": extended_properties,
+                            "qualifiedName": qualified_name,
+                            "additionalProperties": additional_properties,
+                            "displayName": display_name,
+                            "description": description,
+                            "scope": scope,
+                            "purposes": purposes,
                             "version": version_identifier
                             }
                         }
 
-                    guid = egeria_client.create_info_supply_chain_segment(info_supply_chain_guid, body)
+                    guid = egeria_client.create_info_supply_chain(body)
                     if guid:
                         update_element_dictionary(qualified_name, {
                             'guid': guid, 'display_name': display_name
                             })
+                        if len(in_supply_chain_guids) > 0:
+                            for nested_chain in in_supply_chain_guids:
+                                egeria_client.compose_info_supply_chains(guid, nested_chain)
+
                         msg = f"==>Created Element `{display_name}` with GUID {guid}\n"
                         logger.success(msg)
-                        return egeria_client.get_info_supply_chain_segment_by_guid(guid, info_supply_chain_guid)
+                        return egeria_client.get_info_supply_chain_by_guid(guid, output_format='MD')
                     else:
                         msg = f"==>Failed to create element `{display_name}` with GUID {guid}\n"
                         logger.error(msg)
@@ -800,12 +943,12 @@ def process_information_supply_chain_segment_upsert_command(egeria_client: Egeri
         return None
 
 
+
 @logger.catch
 def process_information_supply_chain_link_unlink_command(egeria_client: EgeriaTech, txt: str,
                                                          directive: str = "display") -> Optional[str]:
     """
-    Processes a solution blueprint create or update object_action by extracting key attributes such as
-    blueprint name, description, and usage from the given text.
+    Processes a link or unlink command to associate or break up peer supply chains..
 
     :param txt: A string representing the input cell to be processed for
         extracting blueprint-related attributes.
@@ -814,7 +957,7 @@ def process_information_supply_chain_link_unlink_command(egeria_client: EgeriaTe
     """
     command, object_type, object_action = extract_command_plus(txt)
 
-    parsed_output = parse_upsert_command(egeria_client, object_type, object_action, txt, directive)
+    parsed_output = parse_view_command(egeria_client, object_type, object_action, txt, directive)
 
     print(Markdown(parsed_output['display']))
 
@@ -822,13 +965,14 @@ def process_information_supply_chain_link_unlink_command(egeria_client: EgeriaTe
 
     attributes = parsed_output['attributes']
 
-    segment1 = attributes.get('Segment1', {}).get('guid', None)
-    segment2 = attributes.get('Segment1', {}).get('guid', None)
+    component1 = attributes.get('component1', {}).get('guid', None)
+    component2 = attributes.get('component2', {}).get('guid', None)
     label = attributes.get('Link Label', {}).get('value', None)
     description = attributes.get('Description', {}).get('value', None)
 
     valid = parsed_output['valid']
-    exists = parsed_output['exists']
+    exists = component1 is not None and  component2 is not None
+
 
     external_source_guid = attributes.get('External Source GUID', {}).get('value', None)
     external_source_name = attributes.get('External Source Name', {}).get('value', None)
@@ -854,7 +998,7 @@ def process_information_supply_chain_link_unlink_command(egeria_client: EgeriaTe
 
     elif directive == "process":
         try:
-            if object_action == "Detach":
+            if object_action == "Unlink":
                 if not exists:
                     msg = (f" Link `{label}` does not exist! Updating result document with Link "
                            f"object_action\n")
@@ -868,16 +1012,18 @@ def process_information_supply_chain_link_unlink_command(egeria_client: EgeriaTe
                         f"==> Validation of {command} completed successfully! Proceeding to apply the changes.\n"))
 
                     body = body_slimmer({
-                        "class": "MetadataSourceRequestBody", "externalSourceGUID": external_source_guid,
-                        "externalSourceName": external_source_name, "effectiveTime": effective_time,
-                        "forLineage": False, "forDuplicateProcessing": False
-
+                        "class": "MetadataSourceRequestBody",
+                        "externalSourceGUID": external_source_guid,
+                        "externalSourceName": external_source_name,
+                        "effectiveTime": effective_time,
+                        "forLineage": False,
+                        "forDuplicateProcessing": False
                         })
 
-                egeria_client.detach_info_supply_chain_segments(segment1, segment2, body)
+                egeria_client.unlink_peer_info_supply_chains(component1, component2, body)
 
-                logger.success(f"===> Detached segment with {label} from `{segment1}`to {segment2}\n")
-                out = parsed_output['display'].replace('Detach', 'Link', 1)
+                logger.success(f"===> Detached segment with {label} from `{component1}`to {component2}\n")
+                out = parsed_output['display'].replace('Unlink', 'Link', 1)
 
                 return (out)
 
@@ -894,14 +1040,20 @@ def process_information_supply_chain_link_unlink_command(egeria_client: EgeriaTe
                     return
                 else:
                     body = {
-                        "class": "InformationSupplyChainLinkRequestBody", "effectiveTime": effective_time,
-                        "forLineage": False, "forDuplicateProcessing": False, "properties": {
-                            "class": "InformationSupplyChainLinkProperties", "label": label, "description": description,
-                            "effectiveFrom": effective_from, "effectiveTo": effective_to
+                        "class": "RelationshipRequestBody",
+                        "effectiveTime": effective_time,
+                        "forLineage": False,
+                        "forDuplicateProcessing": False,
+                        "properties": {
+                            "class": "InformationSupplyChainLinkProperties",
+                            "label": label,
+                            "description": description,
+                            "effectiveFrom": effective_from,
+                            "effectiveTo": effective_to
                             }
                         }
 
-                    egeria_client.link_info_supply_chain_segments(segment1, segment2, body)
+                    egeria_client.link_peer_info_supply_chain(component1, component2, body)
                     msg = f"==>Created {object_type} link named `{label}`\n"
                     logger.success(msg)
                     out = parsed_output['display'].replace('Link', 'Detach', 1)
@@ -983,3 +1135,5 @@ def process_sol_arch_list_command(egeria_client: EgeriaTech, txt: str, kind:str,
             return None
     else:
         return None
+
+