pyegeria 5.4.4.2__py3-none-any.whl → 5.4.4.4__py3-none-any.whl

pyegeria/glossary_manager.py

@@ -87,15 +87,17 @@ class GlossaryManager(CollectionManager):
             user_pwd: str = None,
             token: str = None,
             ):
-        self.gl_mgr_command_root: str
         self.view_server = view_server
         self.platform_url = platform_url
         self.user_id = user_id
         self.user_pwd = user_pwd
+        self.url_marker = "glossary-manager"
+
 
         CollectionManager.__init__(self, view_server, platform_url, user_id, user_pwd, token)
         result = self.get_platform_origin()
         logger.info(f"GlossaryManager initialized, platform origin is: {result}")
+        self.glossary_command_root = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager"
     #
     #       Get Valid Values for Enumerations
     #
@@ -990,94 +992,6 @@ class GlossaryManager(CollectionManager):
 
 
     @dynamic_catch
-    async def _async_update_term_status(self, term_guid: str, status: str = None,
-                                              body: dict | UpdateStatusRequestBody = None):
-        """Update the status of a collection. Async version.
-
-        Parameters
-        ----------
-        collection_guid: str
-            The guid of the collection to update.
-        status: str, optional
-            The new lifecycle status for the collection. Ignored, if the body is provided.
-        body: dict | UpdateStatusRequestBody, optional
-            A structure representing the details of the collection to create. If supplied, these details
-            supersede the status parameter provided.
-
-        Returns
-        -------
-        Nothing
-
-        Raises
-        ------
-        InvalidParameterException
-          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
-          Raised by the server when an issue arises in processing a valid request
-        NotAuthorizedException
-          The principle specified by the user_id does not have authorization for the requested action
-
-        Notes
-        -----
-        JSON Structure looks like:
-         {
-          "class": "UpdateStatusRequestBody",
-          "status": "APPROVED",
-          "externalSourceGUID": "add guid here",
-          "externalSourceName": "add qualified name here",
-          "effectiveTime": "{{$isoTimestamp}}",
-          "forLineage": false,
-          "forDuplicateProcessing": false
-        }
-        """
-
-        url = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/glossary-manager/metadata-elements/{term_guid}/update-status"
-        await self._async_update_status_request(url, status, body)
-        logger.info(f"Updated status for term {term_guid}")
-
-    @dynamic_catch
-    def update_term_status(self, term_guid: str, status: str = None,
-                                 body: dict | UpdateStatusRequestBody = None):
-        """Update the status of a DigitalProduct collection.
-
-        Parameters
-        ----------
-        collection_guid: str
-            The guid of the collection to update.
-        status: str, optional
-            The new lifecycle status for the digital product. Ignored, if the body is provided.
-        body: dict | UpdateStatusRequestBody, optional
-            A structure representing the details of the collection to create. If supplied, these details
-            supersede the status parameter provided.
-
-        Returns
-        -------
-        Nothing
-
-        Raises
-        ------
-        InvalidParameterException
-          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
-        PropertyServerException
-          Raised by the server when an issue arises in processing a valid request
-        NotAuthorizedException
-          The principle specified by the user_id does not have authorization for the requested action
-
-        Notes
-        -----
-        JSON Structure looks like:
-         {
-          "class": "UpdateStatusRequestBody",
-          "status": "APPROVED",
-          "externalSourceGUID": "add guid here",
-          "externalSourceName": "add qualified name here",
-          "effectiveTime": "{{$isoTimestamp}}",
-          "forLineage": false,
-          "forDuplicateProcessing": false
-        }
-        """
-        loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_update_collection_status(term_guid, status, body))
 
 
     async def _async_delete_term(

pyegeria/governance_officer.py

@@ -849,99 +849,6 @@ class GovernanceOfficer(Client2):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(self._async_update_governance_definition(guid, body))
 
-    @dynamic_catch
-    async def _async_update_governance_definition_status(self, guid: str, status: str = None,
-                                                         body: dict | UpdateStatusRequestBody = None) -> None:
-        """ Update the status of a governance definition. Async Version.
-
-        Parameters
-        ----------
-        guid: str
-            guid of the governance definition to update.
-        status: str, optional, default is None
-            The status to update the governance definition to. Superseded by the body definition if present.
-        body: dict
-            A dictionary containing the updates to the governance definition.
-
-        Returns
-        -------
-
-        None
-
-        Raises
-        ------
-        InvalidParameterException
-            one of the parameters is null or invalid or
-        PropertyServerException
-            There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
-            the requesting user is not authorized to issue this request.
-
-        Notes
-        ----
-
-        Body structure:
-        {
-          "class": "UpdateGovernanceDefinitionRequestBody",
-          "externalSourceGUID": "add guid here",
-          "externalSourceName": "add qualified name here",
-          "effectiveTime": "{{$isoTimestamp}}",
-          "forLineage": false,
-          "forDuplicateProcessing": false,
-          "status": "ACTIVE"
-        }
-        """
-
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/{self.url_marker}/governance-defnitions/"
-            f"{guid}/update-status")
-
-        # await self._async_update_status_request(url, status, body)
-
-    def update_governance_definition_status(self, guid: str, status: str = None,
-                                            body: dict | UpdateStatusRequestBody = None) -> None:
-        """ Update the status of a governance definition.
-
-            Parameters
-            ----------
-            guid: str
-                guid of the information governance definition to update.
-            status: str, optional, default is None
-                The status to update the governance definition to. Superseded by the body definition if present.
-            body: dict
-                A dictionary containing the updates to the governance definition.
-
-            Returns
-            -------
-
-            None
-
-            Raises
-            ------
-            InvalidParameterException
-                one of the parameters is null or invalid or
-            PropertyServerException
-                There is a problem adding the element properties to the metadata repository or
-            UserNotAuthorizedException
-                the requesting user is not authorized to issue this request.
-
-            Notes
-            ----
-
-            Body structure:
-            {
-              "class" : "UpdateGovernanceDefinitionRequestBody",
-              "externalSourceGUID": "add guid here",
-              "externalSourceName": "add qualified name here",
-              "effectiveTime" : "{{$isoTimestamp}}",
-              "forLineage" : false,
-              "forDuplicateProcessing" : false,
-              "status": "ACTIVE"
-            }
-            """
-        loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_update_governance_definition_status(guid, status, body))
-
     @dynamic_catch
     async def _async_delete_governance_definition(self, definition_guid: str,
                                                   body: dict | DeleteRequestBody = None,
@@ -1430,7 +1337,7 @@ class GovernanceOfficer(Client2):
         logger.info(f"Detached digital supporting definitions: {definition_guid1} -> {definition_guid2}")
 
     @dynamic_catch
-    def detach_supporting_definitions(self, definition_guid1: str, relationship_type: str, definition_guid2: str,
+    def detach_supporting_definitions(self, definition_guid: str, relationship_type: str, definition_guid2: str,
                                       body: dict | DeleteRequestBody = None) -> None:
         """ Detach a governance definition from a supporting governance definition.
             Request body is optional.
@@ -1476,6 +1383,197 @@ class GovernanceOfficer(Client2):
         loop.run_until_complete(
             self._async_detach_supporting_definitions(definition_guid1, relationship_type, definition_guid2, body))
 
+
+
+    async def _async_attach_governed_by_definition(self, element_guid: str, definition_guid: str,
+                                                   body: dict | NewRelationshipRequestBody = None) -> None:
+        """ Link a governance definition to an element using the GovernedBy relationship. Request body is optional.
+
+        Async Version.
+
+        Parameters
+        ----------
+        element_guid: str
+            guid of the element to be governed.
+        definition_guid: str
+            the governance definition guid.
+        body: dict
+            The body describing the link between the two.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        PyegeriaException
+        ValidationError
+
+        Notes
+        ----
+
+        Body structure:
+       {
+           "class" : "NewRelationshipRequestBody",
+           "properties" : {
+             "class" : "GovernedByProperties",
+             "label" : "add label here",
+             "description" : "add description here"
+           },
+           "externalSourceGUID": "Add guid here",
+           "externalSourceName": "Add qualified name here",
+           "forLineage": false,
+           "forDuplicateProcessing": false,
+           "effectiveTime" : "{{$isoTimestamp}}"
+        }
+        """
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/"
+            f"{self.url_marker}/elements/{element_guid}/governed-by/{definition_guid}/attach"
+        )
+        await self._async_new_relationship_request(url, "GovernedByProperties", body)
+        logger.info(f"Linked Governed-By {definition_guid1} -> {definition_guid2}")
+
+    @dynamic_catch
+    def attach_governed_by_definition(self, element_guid: str, definition_guid: str,
+                                      body: dict | NewRelationshipRequestBody = None) -> None:
+        """ Link a governance definition to an element using the GovernedBy relationship. Request body is optional.
+
+        Parameters
+        ----------
+        element_guid: str
+            guid of the element to be governed.
+        definition_guid: str
+            the governance definition guid.
+        body: dict
+            The body describing the link between the two.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        PyegeriaException
+        ValidationError
+
+        Notes
+        ----
+
+        Body structure:
+       {
+           "class" : "NewRelationshipRequestBody",
+           "properties" : {
+             "class" : "GovernedByProperties",
+             "label" : "add label here",
+             "description" : "add description here"
+           },
+           "externalSourceGUID": "Add guid here",
+           "externalSourceName": "Add qualified name here",
+           "forLineage": false,
+           "forDuplicateProcessing": false,
+           "effectiveTime" : "{{$isoTimestamp}}"
+        }
+        """
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(
+            self._async_attach_governed_by_definition(element_guid, definition_guid, body))
+
+    @dynamic_catch
+    async def _async_detach_governed_by_definition(self, element_guid: str, definition_guid: str,
+                                                   body: dict | DeleteRequestBody = None) -> None:
+        """ Detach a governance definition from a supporting governance definition.
+            Request body is optional. Async Version.
+
+        Parameters
+        ----------
+        element_guid: str
+            guid of the element to be governed.
+        definition_guid: str
+            the governance definition guid.
+        body: dict
+            The body describing the link between the two.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+
+        Notes
+        ----
+
+        Body structure:
+        {
+          "class" : "DeleteRequestBody",
+          "externalSourceGUID": "add guid here",
+          "externalSourceName": "add qualified name here",
+          "effectiveTime" : "{{$isoTimestamp}}",
+          "forLineage" : false,
+          "forDuplicateProcessing" : false
+        }
+        """
+        url = (
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/"
+            f"{self.url_marker}/elements/{element_guid}/governed-by/{definition_guid}/detach"
+        )
+        await self._async_delete_request(url, body)
+        logger.info(f"Detached governed-by relationshup between: {definition_guid} -> {element_guid}")
+
+    @dynamic_catch
+    def detach_governed_by_definitio(self, element_guid: str, definition_guid: str,
+                                      body: dict | DeleteRequestBody = None) -> None:
+        """ Detach a governance definition from a supporting governance definition.
+            Request body is optional.
+
+        Parameters
+        ----------
+        element_guid: str
+            guid of the element to be governed.
+        definition_guid: str
+            the governance definition guid.
+        body: dict
+            The body describing the link between the two.
+
+        Returns
+        -------
+        None
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+
+        Notes
+        ----
+
+        Body structure:
+        {
+          "class" : "DeleteRequestBody",
+          "externalSourceGUID": "add guid here",
+          "externalSourceName": "add qualified name here",
+          "effectiveTime" : "{{$isoTimestamp}}",
+          "forLineage" : false,
+          "forDuplicateProcessing" : false
+        }
+        """
+        loop = asyncio.get_event_loop()
+        loop.run_until_complete(
+            self._async_detach_governed_by_definition(element_guid, definition_guid, body))
+
+
+
     @dynamic_catch
     async def _async_delete_governance_definition(self, guid: str, body: dict | DeleteRequestBody = None) -> None:
         """ Delete an information supply. Async version.
@@ -1484,7 +1582,7 @@ class GovernanceOfficer(Client2):
         ----------
         guid: str
             GUID of the governance definition to delete.
- 
+
         body: dict, optional
             A dictionary containing the definition of the governance definition to create.
 
@@ -1522,6 +1620,7 @@ class GovernanceOfficer(Client2):
         await self._async_delete_request(url, body)
         logger.info(f"Deleted governance definition: {guid} ")
 
+
     @dynamic_catch
     def delete_governance_definition(self, guid: str, body: dict | DeleteRequestBody = None) -> None:
         """ Delete an information supply. Request body is optional. Async version.

pyegeria/output_formatter.py

@@ -948,6 +948,10 @@ def generate_output(elements: Union[Dict, List[Dict]],
     if search_string is None or search_string == '':
         search_string = "All"
 
+    # Set the output format to DICT to return values to table display
+    if output_format == "TABLE":
+        output_format = "DICT"
+
     # Generate output based on format
     if output_format == 'MERMAID':
         return extract_mermaid_only(elements)

pyegeria/project_manager.py

@@ -72,6 +72,7 @@ class ProjectManager(Client2):
         self.project_command_base: str = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects"
         )
+        self.url_marker = 'project-manager'
         Client2.__init__(self, view_server, platform_url, user_id, user_pwd, token)
 
     def _extract_additional_project_properties(self, element: dict, columns_struct: dict)-> dict:

pyegeria/solution_architect.py

@@ -2612,96 +2612,6 @@ class SolutionArchitect(Client2):
         loop.run_until_complete(self._async_delete_info_supply_chain(guid, body, cascade))
 
 
-    @dynamic_catch
-    async def _async_update_solution_element_status(self, guid: str, status: str= None, body: dict| UpdateStatusRequestBody = None,
-                                               ) -> None:
-        """ Update the properties of a blueprint, solution component, or solution port. Async Version.
-
-        Parameters
-        ----------
-        guid: str
-            guid of the information supply chain to update.
-        body: dict | UpdateStatusRequestBody, optional
-            A dictionary containing the updates to the supply chain.
-        status: str, optional
-            The status to update the supply chain to.
-
-        Returns
-        -------
-
-        None
-
-        Raises
-        ------
-        InvalidParameterException
-            one of the parameters is null or invalid or
-        PropertyServerException
-            There is a problem adding the element properties to the metadata repository or
-        UserNotAuthorizedException
-            the requesting user is not authorized to issue this request.
-
-        Notes
-        ----
-
-        Body structure:
-             {
-              "class" : "UpdateStatusRequestBody",
-              "status" : "APPROVED",
-              "externalSourceGUID": "add guid here",
-              "externalSourceName": "add qualified name here",
-              "effectiveTime" : "{{$isoTimestamp}}",
-              "forLineage" : false,
-              "forDuplicateProcessing" : false
-            }
-        """
-
-        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/solution-architect/"
-               f"solution-blueprints/{guid}/update")
-
-        await self._async_update_status_request(url, status, body)
-
-    @dynamic_catch
-    def update_solution_element_status(self, guid: str, status: str = None, body: dict| UpdateStatusRequestBody = None) -> None:
-        """ Update the status of a blueprint, solution component, or solution port.
-
-            Parameters
-            ----------
-            guid: str
-                guid of the information supply chain to update.
-            body: dict
-                A dictionary containing the updates to the supply chain.
-
-            Returns
-            -------
-            None
-
-            Raises
-            ------
-            InvalidParameterException
-                one of the parameters is null or invalid or
-            PropertyServerException
-                There is a problem adding the element properties to the metadata repository or
-            UserNotAuthorizedException
-                the requesting user is not authorized to issue this request.
-
-            Notes
-            ----
-
-            Body structure:
-            {
-              "class" : "SolutionElementStatusRequestBody",
-              "status" : "APPROVED",
-              "externalSourceGUID": "add guid here",
-              "externalSourceName": "add qualified name here",
-              "effectiveTime" : "{{$isoTimestamp}}",
-              "forLineage" : false,
-              "forDuplicateProcessing" : false
-            }
-            """
-        loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_update_solution_element_status(guid = guid, status= status, body=body))
-
-
     @dynamic_catch
     async def _async_link_solution_component_to_blueprint(self, blueprint_guid: str, component_guid: str,
                                                           body: dict | NewRelationshipRequestBody) -> None:

pyegeria/utils.py

@@ -57,70 +57,6 @@ def print_guid_list(guids):
 #
 
 
-def print_response(response):
-    """
-
-    Args:
-        response:
-
-    Returns:
-        : str
-    """
-    pretty_response = json.dumps(response.json(), indent=4)
-    print(" ")
-    print("Response: ")
-    print(pretty_response)
-    print(" ")
-
-
-def print_unexpected_response(server_name, platform_name, platform_url, response):
-    """
-
-    Args:
-        server_name:
-        platform_name:
-        platform_url:
-        response:
-    """
-    if response.status_code == 200:
-        related_http_code = response.json().get("related_http_code")
-        if related_http_code == 200:
-            print("Unexpected response from server " + server_name)
-            print_response(response)
-        else:
-            exceptionErrorMessage = response.json().get("exceptionErrorMessage")
-            exceptionSystemAction = response.json().get("exceptionSystemAction")
-            exceptionUserAction = response.json().get("exceptionUserAction")
-            if exceptionErrorMessage is not None:
-                print(exceptionErrorMessage)
-                print(" * " + exceptionSystemAction)
-                print(" * " + exceptionUserAction)
-            else:
-                print("Unexpected response from server " + server_name)
-                print_response(response)
-    else:
-        print(
-            "Unexpected response from server platform "
-            + platform_name
-            + " at "
-            + platform_url
-        )
-        print_response(response)
-
-
-def get_last_guid(guids):
-    """
-
-    Args:
-        guids:
-
-    Returns:
-
-    """
-    if guids is None:
-        return None
-    else:
-        return guids[-1]
 
 
 def body_slimmer(body: dict) -> dict:
@@ -362,5 +298,10 @@ def dynamic_catch(func: T) -> T:
     else:
         return func  # Return the function unwrapped
 
+def make_format_set_name_from_type(obj_type: str)-> str:
+    formatted_name = obj_type.replace(" ", "-")
+    return f"{formatted_name}-DrE"
+
+
 if __name__ == "__main__":
     print("Main-Utils")

{pyegeria-5.4.4.2.dist-info → pyegeria-5.4.4.4.dist-info}/METADATA

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