pyegeria 5.4.0.25__py3-none-any.whl → 5.4.0.27__py3-none-any.whl

pyegeria/project_manager.py

@@ -8,33 +8,19 @@ Copyright Contributors to the ODPi Egeria project.
 """
 
 import asyncio
-import inspect
-from datetime import datetime
-from typing import Optional, Annotated, Literal, Union
 
-from loguru import logger
-from pydantic import ValidationError, Field, HttpUrl
-
-from pyegeria._exceptions_new import PyegeriaInvalidParameterException
-from pyegeria._globals import NO_ELEMENTS_FOUND, NO_GUID_RETURNED, NO_MEMBERS_FOUND
-from pyegeria._output_formats import select_output_format_set, get_output_format_type_match
+from pyegeria._client_new import Client2
 from pyegeria.load_config import get_app_config
 from pyegeria.models import (SearchStringRequestBody, FilterRequestBody, GetRequestBody, NewElementRequestBody,
-                             ReferenceableProperties, InitialClassifications, TemplateRequestBody,
-                             UpdateElementRequestBody, UpdateStatusRequestBody, NewRelationshipRequestBody,
-                             DeleteRequestBody, UpdateRelationshipRequestBody, ResultsRequestBody,
-                             get_defined_field_values, PyegeriaModel)
-from pyegeria.output_formatter import (generate_output,
-                                       _extract_referenceable_properties, populate_columns_from_properties,
-                                       get_required_relationships)
-from pyegeria._client_new import Client2
+                             TemplateRequestBody)
 from pyegeria.utils import body_slimmer, dynamic_catch
 
-
 app_settings = get_app_config()
 EGERIA_LOCAL_QUALIFIER = app_settings.User_Profile.egeria_local_qualifier
 from pyegeria._globals import NO_ELEMENTS_FOUND, NO_PROJECTS_FOUND
 
+PROJECT_TYPES = ["Project", "Campaign", "StudyProject", "Task", "PersonalProject"]
+
 class ProjectManager(Client2):
     """
     Create and manage projects. Projects may be organized in a hierarchy.
@@ -54,33 +40,36 @@ class ProjectManager(Client2):
     """
 
     def __init__(
-        self,
-        view_server: str,
-        platform_url: str,
-        user_id: str,
-        user_pwd: str = None,
-        token: str = None,
-    ):
+            self,
+            view_server: str,
+            platform_url: str,
+            user_id: str,
+            user_pwd: str = None,
+            token: str = None,
+            ):
         self.view_server = view_server
         self.platform_url = platform_url
         self.user_id = user_id
         self.user_pwd = user_pwd
         self.project_command_base: str = (
-            f"/api/open-metadata/project-manager/metadata-elements"
+            f"/api/open-metadata/project-manager/projects"
         )
-        Client.__init__(self, view_server, platform_url, user_id, user_pwd, token)
+        Client2.__init__(self, view_server, platform_url, user_id, user_pwd, token)
+
 
+    def _generate_project_output(self):
+        pass
     #
     #       Retrieving Projects= Information - https://egeria-project.org/concepts/project
     #
     async def _async_get_linked_projects(
-        self,
-        parent_guid: str,
-        project_status: str = None,
-        effective_time: str = None,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
+            self,
+            parent_guid: str,
+            project_status: str = None,
+            effective_time: str = None,
+            start_from: int = 0,
+            page_size: int = None,
+            ) -> list | str:
         """Returns the list of projects that are linked off of the supplied element. Any relationship will do.
              The request body is optional, but if supplied acts as a filter on project status. Async version.
 
@@ -122,7 +111,7 @@ class ProjectManager(Client2):
         body = {
             "filter": project_status,
             "effectiveTime": effective_time,
-        }
+            }
         body_s = body_slimmer(body)
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/"
@@ -133,13 +122,13 @@ class ProjectManager(Client2):
         return resp.json().get("elements", "No linked projects found")
 
     def get_linked_projects(
-        self,
-        parent_guid: str,
-        project_status: str = None,
-        effective_time: str = None,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
+            self,
+            parent_guid: str,
+            project_status: str = None,
+            effective_time: str = None,
+            start_from: int = 0,
+            page_size: int = None,
+            ) -> list | str:
         """Returns the list of projects that are linked off of the supplied element. Any relationship will do.
              The request body is optional, but if supplied acts as a filter on project status.
 
@@ -182,17 +171,17 @@ class ProjectManager(Client2):
                 effective_time,
                 start_from,
                 page_size,
+                )
             )
-        )
         return resp
 
     async def _async_get_classified_projects(
-        self,
-        project_classification: str,
-        effective_time: str = None,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
+            self,
+            project_classification: str,
+            effective_time: str = None,
+            start_from: int = 0,
+            page_size: int = None,
+            ) -> list | str:
         """Returns the list of projects with a particular classification. The name of the classification is
             supplied in the request body. Examples of these classifications include StudyProject, PersonalProject,
             Campaign or Task. There is also GlossaryProject and GovernanceProject. Async version.
@@ -233,7 +222,7 @@ class ProjectManager(Client2):
         body = {
             "filter": project_classification,
             "effectiveTime": effective_time,
-        }
+            }
         body_s = body_slimmer(body)
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/"
@@ -244,12 +233,12 @@ class ProjectManager(Client2):
         return resp.json()
 
     def get_classified_projects(
-        self,
-        project_classification: str,
-        effective_time: str = None,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
+            self,
+            project_classification: str,
+            effective_time: str = None,
+            start_from: int = 0,
+            page_size: int = None,
+            ) -> list | str:
         """Returns the list of projects with a particular classification. The name of the classification is
             supplied in the request body. Examples of these classifications include StudyProject, PersonalProject,
             Campaign or Task. There is also GlossaryProject and GovernanceProject.
@@ -290,18 +279,18 @@ class ProjectManager(Client2):
                 effective_time,
                 start_from,
                 page_size,
+                )
             )
-        )
         return resp
 
     async def _async_get_project_team(
-        self,
-        project_guid: str,
-        team_role: str = None,
-        effective_time: str = None,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
+            self,
+            project_guid: str,
+            team_role: str = None,
+            effective_time: str = None,
+            start_from: int = 0,
+            page_size: int = None,
+            ) -> list | str:
         """Returns the list of actors that are linked off of the project. This includes the project managers.
             The optional request body allows a teamRole to be specified as a filter. To filter out the project managers,
             specify ProjectManagement as the team role. See https://egeria-project.org/concepts/project for details.
@@ -355,13 +344,13 @@ class ProjectManager(Client2):
         return result
 
     def get_project_team(
-        self,
-        project_guid: str,
-        team_role: str = None,
-        effective_time: str = None,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
+            self,
+            project_guid: str,
+            team_role: str = None,
+            effective_time: str = None,
+            start_from: int = 0,
+            page_size: int = None,
+            ) -> list | str:
         """Returns the list of actors that are linked off of the project. This includes the project managers.
             The optional request body allows a teamRole to be specified as a filter. To filter out the project managers,
             specify ProjectManagement as the team role. See https://egeria-project.org/concepts/project for details.
@@ -406,20 +395,22 @@ class ProjectManager(Client2):
                 effective_time,
                 start_from,
                 page_size,
+                )
             )
-        )
         return resp
 
+    @dynamic_catch
     async def _async_find_projects(
-        self,
-        search_string: str,
-        effective_time: str = None,
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = False,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
+            self,
+            search_string: str, classification_names: list[str] = None, metadata_element_types: list[str] = None,
+            starts_with: bool = False,
+            ends_with: bool = False,
+            ignore_case: bool = False,
+            start_from: int = 0,
+            page_size: int = 0,
+            output_format: str = "json", output_format_set: str | dict = None,
+            body: dict | SearchStringRequestBody = None
+            ) -> list | str:
         """Returns the list of projects matching the search string.
             The search string is located in the request body and is interpreted as a plain string.
             The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
@@ -461,41 +452,36 @@ class ProjectManager(Client2):
 
         """
 
-        if page_size is None:
-            page_size = self.page_size
-        starts_with_s = str(starts_with).lower()
-        ends_with_s = str(ends_with).lower()
-        ignore_case_s = str(ignore_case).lower()
-
-        validate_search_string(search_string)
-
-        if search_string == "*":
-            search_string = None
-
-        body = {
-            "filter": search_string,
-            "effective_time": effective_time,
-        }
-        body_s = body_slimmer(body)
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects/"
-            f"by-search-string?startFrom={start_from}&pageSize={page_size}&startsWith={starts_with_s}&"
-            f"endsWith={ends_with_s}&ignoreCase={ignore_case_s}"
+            f"by-search-string"
         )
 
-        resp = await self._async_make_request("POST", url, body_s)
-        return resp.json().get("elements", NO_ELEMENTS_FOUND)
+        response = await self._async_find_request(url, _type="Project",
+                                                  _gen_output=self._generate_project_output,
+                                                  search_string=search_string,
+                                                  classification_names=classification_names,
+                                                  metadata_element_types=metadata_element_types,
+                                                  starts_with=starts_with, ends_with=ends_with, ignore_case=ignore_case,
+                                                  start_from=start_from, page_size=page_size,
+                                                  output_format=output_format, output_format_set=output_format_set,
+                                                  body=body)
+
+        return response
 
+    @dynamic_catch
     def find_projects(
-        self,
-        search_string: str,
-        effective_time: str = None,
-        starts_with: bool = False,
-        ends_with: bool = False,
-        ignore_case: bool = False,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
+            self,
+            search_string: str, classification_names: list[str] = None, metadata_element_types: list[str] = None,
+            starts_with: bool = False,
+            ends_with: bool = False,
+            ignore_case: bool = False,
+            start_from: int = 0,
+            page_size: int = 0,
+            output_format: str = "json", output_format_set: str | dict = None,
+            body: dict | SearchStringRequestBody = None
+            ) -> list | str:
+
         """Returns the list of projects matching the search string.
             The search string is located in the request body and is interpreted as a plain string.
             The request parameters, startsWith, endsWith and ignoreCase can be used to allow a fuzzy search.
@@ -539,212 +525,192 @@ class ProjectManager(Client2):
         resp = loop.run_until_complete(
             self._async_find_projects(
                 search_string,
-                effective_time,
+                classification_names,
+                metadata_element_types,
                 starts_with,
                 ends_with,
                 ignore_case,
                 start_from,
                 page_size,
+                output_format,
+                output_format_set,
+                body,
+                )
             )
-        )
 
         return resp
 
+    @dynamic_catch
     async def _async_get_projects_by_name(
-        self,
-        name: str,
-        effective_time: str = None,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
-        """Returns the list of projects with a particular name. Async version.
-
-        Parameters
-        ----------
-        name: str,
-            name to use to find matching collections.
-        effective_time: str, [default=None], optional
-            Effective time of the query. If not specified will default to any time. ISO 8601 format.
-
-        start_from: int, [default=0], optional
-                    When multiple pages of results are available, the page number to start from.
-        page_size: int, [default=None]
-            The number of items to return in a single page. If not specified, the default will be taken from
-            the class instance.
-        Returns
-        -------
-        List | str
-
-        A list of collections match matching the name. Returns a string if none found.
-
-        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
-
-        """
-
-        if page_size is None:
-            page_size = self.page_size
-
-        validate_search_string(name)
-
-        body = {
-            "filter": name,
-            "effective_time": effective_time,
-        }
-        body_s = body_slimmer(body)
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects/"
-            f"by-name?startFrom={start_from}&pageSize={page_size}"
-        )
-
-        resp = await self._async_make_request("POST", url, body_s)
-        return resp.json().get("elements", NO_PROJECTS_FOUND)
-
+            self,  filter_string: str = None, classification_names: list[str] = None,
+                                             body: dict | FilterRequestBody = None,
+                                             start_from: int = 0, page_size: int = 0,
+                                             output_format: str = 'JSON',
+                                             output_format_set: str | dict = None) -> list | str:
+            url = f"{self.project_command_base}/by-name"
+
+            response = await self._async_get_name_request(url, _type="Projects",
+                                                  _gen_output=self._generate_projects_output,
+                                                  filter_string=filter_string,
+                                                  classification_names=classification_names,
+                                                  start_from=start_from, page_size=page_size,
+                                                  output_format=output_format, output_format_set=output_format_set,
+                                                  body=body)
+
+            return response
+
+    @dynamic_catch
     def get_projects_by_name(
-        self,
-        name: str,
-        effective_time: str = None,
-        start_from: int = 0,
-        page_size: int = None,
-    ) -> list | str:
-        """Returns the list of projects with a particular name.
-
-        Parameters
-        ----------
-        name: str,
-            name to use to find matching collections.
-        effective_time: str, [default=None], optional
-            Effective time of the query. If not specified will default to any time. ISO 8601 format.
-
-        start_from: int, [default=0], optional
-                    When multiple pages of results are available, the page number to start from.
-        page_size: int, [default=None]
-            The number of items to return in a single page. If not specified, the default will be taken from
-            the class instance.
-        Returns
-        -------
-        List | str
+            self, filter_string: str = None, classification_names: list[str] = None,
+            body: dict | FilterRequestBody = None,
+            start_from: int = 0, page_size: int = 0,
+            output_format: str = 'JSON',
+            output_format_set: str | dict = None) -> list | str:
 
-        A list of collections match matching the name. Returns a string if none found.
-
-        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
-
-        """
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
             self._async_get_projects_by_name(
-                name, effective_time, start_from, page_size
+                filter_string,
+                classification_names,
+                body,
+                start_from,
+                page_size,
+                output_format,
+                output_format_set,
+                )
             )
-        )
-
         return resp
 
-    async def _async_get_project_by_guid(
-        self,
-        project_guid: str,
-        effective_time: str = None,
-    ) -> dict | str:
+    @dynamic_catch
+    async def _async_get_project_by_guid(self, project_guid: str, element_type: str = None,
+                                            body: dict | GetRequestBody = None,
+                                            output_format: str = 'JSON',
+                                            output_format_set: str | dict = None) -> dict | str:
         """Return the properties of a specific project. Async version.
 
-        Parameters
-        ----------
-        project_guid: str,
-            unique identifier of the project.
-        effective_time: str, [default=None], optional
-             Effective time of the query. If not specified will default to any time. Time in ISO8601 format is assumed.
-
-
-        Returns
-        -------
-        dict | str
-
-        A JSON dict representing the specified project. Returns a string if none found.
-
-        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
+            Parameters
+            ----------
+            project_guid: str,
+                unique identifier of the collection.
+            element_type: str, default = None, optional
+                type of collection - Collection, DataSpec, Agreement, etc.
+            body: dict | GetRequestBody, optional, default = None
+                full request body.
+            output_format: str, default = "JSON"
+                - one of "DICT", "MERMAID" or "JSON"
+            output_format_set: str | dict, optional, default = None
+                    The desired output columns/fields to include.
+
+            Returns
+            -------
+            dict | str
+
+            A JSON dict representing the specified collection. Returns a string if none found.
+
+            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
+            ----
+            Body sample:
+            {
+              "class": "GetRequestBody",
+              "asOfTime": "{{$isoTimestamp}}",
+              "effectiveTime": "{{$isoTimestamp}}",
+              "forLineage": false,
+              "forDuplicateProcessing": false
+            }
+            """
 
-        """
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects/"
+               f"{project_guid}")
+        type = element_type if element_type else "Collection"
 
-        validate_guid(project_guid)
-        body = {
-            "effective_time": effective_time,
-        }
-        url = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects/{project_guid}"
+        response = await self._async_get_guid_request(url, _type=type,
+                                                      _gen_output=self._generate_collection_output,
+                                                      output_format=output_format, output_format_set=output_format_set,
+                                                      body=body)
 
-        resp = await self._async_make_request("GET", url, body)
-        return resp.json().get('element',NO_ELEMENTS_FOUND)
+        return response
 
-    def get_project_by_guid(self, project_guid: str, effective_time: str = None) -> dict | str:
+    @dynamic_catch
+    def get_project_by_guid(self, project_guid: str, element_type: str = None,
+                                            body: dict | GetRequestBody = None,
+                                            output_format: str = 'JSON',
+                                            output_format_set: str | dict = None) -> dict | str:
         """Return the properties of a specific project.
 
-        Parameters
-        ----------
-        project_guid: str,
-            unique identifier of the project.
-        effective_time: str, [default=None], optional
-             Effective time of the query. If not specified will default to any time. Time in ISO8601 format is assumed.
-
-
-        Returns
-        -------
-        dict | str
-
-        A JSON dict representing the specified project. Returns a string if none found.
-
-        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
-
-        """
+            Parameters
+            ----------
+            project_guid: str,
+                unique identifier of the collection.
+            element_type: str, default = None, optional
+                type of collection - Collection, DataSpec, Agreement, etc.
+            body: dict | GetRequestBody, optional, default = None
+                full request body.
+            output_format: str, default = "JSON"
+                - one of "DICT", "MERMAID" or "JSON"
+            output_format_set: str | dict, optional, default = None
+                    The desired output columns/fields to include.
+
+            Returns
+            -------
+            dict | str
+
+            A JSON dict representing the specified collection. Returns a string if none found.
+
+            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
+            ----
+            Body sample:
+            {
+              "class": "GetRequestBody",
+              "asOfTime": "{{$isoTimestamp}}",
+              "effectiveTime": "{{$isoTimestamp}}",
+              "forLineage": false,
+              "forDuplicateProcessing": false
+            }
+            """
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
-            self._async_get_project_by_guid(project_guid, effective_time)
-        )
+            self._async_get_project_by_guid(project_guid, element_type, body, output_format, output_format_set )
+            )
 
         return resp
 
+    @dynamic_catch
     async def _async_get_project_graph(
-        self,
-        project_guid: str,
-        effective_time: str = None,
-    ) -> dict | str:
+            self,
+            project_guid: str,
+            element_type: str = None,
+            body: dict | GetRequestBody = None,
+            output_format: str = 'JSON',
+            output_format_set: str | dict = None,
+            ) -> dict | str:
         """Return the mermaid graph of a specific project. Async version.
 
         Parameters
         ----------
         project_guid: str,
             unique identifier of the project.
-        effective_time: str, [default=None], optional
-             Effective time of the query. If not specified will default to any time. Time in ISO8601 format is assumed.
-
+        body: dict | GetRequestBody, optional, default = None
+            full request body.
 
         Returns
         -------
@@ -763,25 +729,34 @@ class ProjectManager(Client2):
 
         """
 
-        validate_guid(project_guid)
-        body = {
-            "effective_time": effective_time,
-        }
-        url = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects/{project_guid}/graph"
 
-        resp = await self._async_make_request("GET", url, body)
-        return resp.json().get('element',NO_ELEMENTS_FOUND)
+        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/pr"
+               f"ojects/{project_guid}/graph")
 
-    def get_project_graph(self, project_guid: str, effective_time: str = None) -> dict | str:
-        """Return the mermaid graph of a specific project.
+        response = await self._async_get_guid_request(url, _type=element_type,
+                                                      _gen_output=self._generate_project_output,
+                                                      output_format=output_format, output_format_set=output_format_set,
+                                                      body=body)
+
+        return response
+
+    @dynamic_catch
+    def get_project_graph(
+            self,
+            project_guid: str,
+            element_type: str = None,
+            body: dict | GetRequestBody = None,
+            output_format: str = 'JSON',
+            output_format_set: str | dict = None,
+            ) -> dict | str:
+        """Return the mermaid graph of a specific project. Async version.
 
         Parameters
         ----------
         project_guid: str,
             unique identifier of the project.
-        effective_time: str, [default=None], optional
-             Effective time of the query. If not specified will default to any time. Time in ISO8601 format is assumed.
-
+        body: dict | GetRequestBody, optional, default = None
+            full request body.
 
         Returns
         -------
@@ -801,31 +776,27 @@ class ProjectManager(Client2):
         """
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
-            self._async_get_project_graph(project_guid, effective_time)
-        )
+            self._async_get_project_graph(project_guid, element_type, body, output_format, output_format_set)
+            )
 
         return resp
 
-
     #
     #   Create project methods
     #
-    async def _async_create_project_w_body(
-        self,
-        body: dict,
-        classification: str = None,
-    ) -> str:
+    @dynamic_catch
+    async def _async_create_project(
+            self,
+            body: dict | NewElementRequestBody,
+            ) -> str:
         """Create project: https://egeria-project.org/concepts/project Async version.
 
         Parameters
         ----------.
         body: dict
-            A dict representing the details of the project to create.
-        classification: str, optional
-            An optional project classification. See https://egeria-project.org/types/1/0130-Projects for values.
-        view_server: str, optional, defaults to None
-            The name of the server to  configure. If not provided, the server name associated with the
-            instance is used.
+            A dict representing the details of the project to create. To create different kinds of projects,
+            set the initial_classifications in the body to be, for instance, "PersonalProject" or "Campaign".
+
 
         Returns
         -------
@@ -844,11 +815,17 @@ class ProjectManager(Client2):
 
         Body structure like:
         {
+          "class": "NewElementRequestBody",
           "anchorGUID" : "anchor GUID, if set then isOwnAnchor=false",
           "isOwnAnchor" : False,
           "parentGUID" : "parent GUID, if set, set all parameters beginning 'parent'",
           "parentRelationshipTypeName" : "open metadata type name",
           "parentAtEnd1": True,
+          "initialClassifications" : {
+                "Folder" : {
+                  "class": "FolderProperties"
+                }
+              },
           "projectProperties": {
             "class" : "ProjectProperties",
             "qualifiedName": "Must provide a unique name here",
@@ -865,33 +842,22 @@ class ProjectManager(Client2):
 
         """
 
-        if classification is None:
-            url = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects"
-        else:
-            url = (
-                f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects?"
-                f"classificationName={classification}"
-            )
-        body_s = body_slimmer(body)
-        resp = await self._async_make_request("POST", url, body_s)
-        return resp.json().get("guid", "No GUID returned")
 
-    def create_project_w_body(
-        self,
-        body: dict,
-        classification: str = None,
-    ) -> str:
+        url = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects"
+
+        return await self._async_create_element_body_request(body, ["ProjectProperties"], body)
+
+    @dynamic_catch
+    def create_project(
+            self,
+            body: dict | NewElementRequestBody,
+            ) -> str:
         """Create project: https://egeria-project.org/concepts/project
 
         Parameters
         ----------.
         body: dict
             A dict representing the details of the project to create.
-        classification: str, optional
-            An optional project classification. See https://egeria-project.org/types/1/0130-Projects for values.
-        view_server: str, optional, defaults to None
-            The name of the server to  configure. If not provided, the server name associated with the instance
-             is used.
 
         Returns
         -------
@@ -932,344 +898,15 @@ class ProjectManager(Client2):
         """
         loop = asyncio.get_event_loop()
         resp = loop.run_until_complete(
-            self._async_create_project_w_body(body, classification)
-        )
-        return resp
-
-    async def _async_create_project(
-        self,
-        anchor_guid: str,
-        parent_guid: str,
-        parent_relationship_type_name: str,
-        parent_at_end1: bool,
-        display_name: str,
-        description: str,
-        classification_name: str = None,
-        identifier: str = None,
-        is_own_anchor: bool = False,
-        project_status: str = None,
-        project_phase: str = None,
-        project_health: str = None,
-        start_date: str = None,
-        planned_end_date: str = None,
-    ) -> str:
-        """Create Project: https://egeria-project.org/concepts/project Async version.
-
-        Parameters
-        ----------
-        classification_name: str, optional
-            Type of project to create; "PersonalProject", "Campaign", etc. If not provided, project will not
-            be classified.
-        anchor_guid: str
-            The unique identifier of the element that should be the anchor for the new element. Set to null if no
-            anchor, or if this collection is to be its own anchor.
-        parent_guid: str
-           The optional unique identifier for an element that should be connected to the newly created element.
-           If this property is specified, parentRelationshipTypeName must also be specified
-        parent_relationship_type_name: str
-            The name of the relationship, if any, that should be established between the new element and the parent
-            element. Examples could be "ResourceList".
-        parent_at_end1: bool
-            Identifies which end any parent entity sits on the relationship.
-        display_name: str
-            The display name of the element. Will also be used as the basis of the qualified_name.
-        description: str
-            A description of the collection.
-        identifier: str
-            A project identifier.
-        is_own_anchor: bool, optional, defaults to False
-            Indicates if the collection should be classified as its own anchor or not.
-        project_status: str, optional
-            The project status
-        project_phase: str, optional
-            Project phase as defined in valid values
-        project_health: str, optional
-            Project health as defined in valid values
-        start_date: str, optional, defaults to None
-            Start date of the project in ISO 8601 string format.
-        planned_end_date: str, optional, defaults to None
-            Planned completion date in ISO 8601 string format.
-
-
-        Returns
-        -------
-        str - the guid of the created project
-
-        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
-
-        """
-
-        if parent_guid is None:
-            is_own_anchor = False
-
-        if classification_name is None:
-            url = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects"
-        else:
-            url = (
-                f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects?"
-                f"classificationName={classification_name}"
+            self._async_create_project(body)
             )
-
-        body = {
-            "anchorGUID": anchor_guid,
-            "isOwnAnchor": str(is_own_anchor).lower(),
-            "parentGUID": parent_guid,
-            "parentRelationshipTypeName": parent_relationship_type_name,
-            "parentAtEnd1": str(parent_at_end1).lower(),
-            "projectProperties": {
-                "class": "ProjectProperties",
-                "qualifiedName": f"{classification_name}-{display_name}-{time.asctime()}",
-                "identifier": identifier,
-                "name": display_name,
-                "description": description,
-                "projectStatus": project_status,
-                "projectPhase": project_phase,
-                "projectHealth": project_health,
-                "startDate": start_date,
-                "plannedEndDate": planned_end_date,
-            },
-        }
-        body_s = body_slimmer(body)
-        resp = await self._async_make_request("POST", url, body_s)
-        return resp.json().get("guid", "No GUID returned")
-
-    def create_project(
-        self,
-        anchor_guid: str,
-        parent_guid: str,
-        parent_relationship_type_name: str,
-        parent_at_end1: bool,
-        display_name: str,
-        description: str,
-        classification_name: str,
-        identifier: str = None,
-        is_own_anchor: bool = False,
-        project_status: str = None,
-        project_phase: str = None,
-        project_health: str = None,
-        start_date: str = None,
-        planned_end_date: str = None,
-    ) -> str:
-        """Create Project: https://egeria-project.org/concepts/project
-
-        Parameters
-        ----------
-        classification_name: str
-            Type of project to create; "PersonalProject", "Campaign", etc. If not provided, the project will not
-            have a project classification.
-        anchor_guid: str
-            The unique identifier of the element that should be the anchor for the new element. Set to null if no
-            anchor, or if this collection is to be its own anchor.
-        parent_guid: str
-           The optional unique identifier for an element that should be connected to the newly created element.
-           If this property is specified, parentRelationshipTypeName must also be specified
-        parent_relationship_type_name: str
-            The name of the relationship, if any, that should be established between the new element and the parent
-            element. Examples could be "ResourceList".
-        parent_at_end1: bool
-            Identifies which end any parent entity sits on the relationship.
-        display_name: str
-            The display name of the element. Will also be used as the basis of the qualified_name.
-        description: str
-            A description of the collection.
-        identifier: str
-            A project identifier.
-        is_own_anchor: bool, optional, defaults to False
-            Indicates if the collection should be classified as its own anchor or not.
-        project_status: str, optional
-            The project status
-        project_phase: str, optional
-            Project phase as defined in valid values
-        project_health: str, optional
-            Project health as defined in valid values
-        start_date: str, optional, defaults to None
-            Start date of the project in ISO 8601 string format.
-        planned_end_date: str, optional, defaults to None
-            Planned completion date in ISO 8601 string format.
-
-
-        Returns
-        -------
-        str - the guid of the created project
-
-        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
-
-        """
-        loop = asyncio.get_event_loop()
-        resp = loop.run_until_complete(
-            self._async_create_project(
-                anchor_guid,
-                parent_guid,
-                parent_relationship_type_name,
-                parent_at_end1,
-                display_name,
-                description,
-                classification_name,
-                identifier,
-                is_own_anchor,
-                project_status,
-                project_phase,
-                project_health,
-                start_date,
-                planned_end_date,
-            )
-        )
-        return resp
-
-    async def _async_create_project_task(
-        self,
-        project_guid: str,
-        display_name: str,
-        identifier: str = None,
-        description: str = None,
-        project_status: str = None,
-        project_phase: str = None,
-        project_health: str = None,
-        start_date: str = None,
-        planned_end_date: str = None,
-    ) -> str:
-        """Create a new project with the Task classification and link it to a project. Async version.
-
-        Parameters
-        ----------
-        project_guid: str
-            The unique identifier of the project to create the task for  (the parent).
-        display_name: str
-            The display name of the element. Will also be used as the basis of the qualified_name.
-        identifier: str
-            A project identifier.
-        description: str
-            A description of the collection.
-        project_status: str, optional, defaults to "OTHER"
-            The project status
-        project_phase: str, optional
-            Project phase as defined in valid values
-        project_health: str, optional
-            Project health as defined in valid values
-        start_date: str, optional, defaults to None
-            Start date of the project in ISO 8601 string format.
-        planned_end_date: str, optional, defaults to None
-            Planned completion date in ISO 8601 string format.
-
-        Returns
-        -------
-        str - the guid of the created project task
-
-        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
-
-        """
-
-        url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects/"
-            f"{project_guid}/task"
-        )
-
-        body = {
-            "class": "ProjectProperties",
-            "qualifiedName": f"task-{display_name}-{time.asctime()}",
-            "identifier": identifier,
-            "name": display_name,
-            "description": description,
-            "projectStatus": project_status,
-            "projectPhase": project_phase,
-            "projectHealth": project_health,
-            "startDate": start_date,
-            "plannedEndDate": planned_end_date,
-        }
-        body_s = body_slimmer(body)
-        resp = await self._async_make_request("POST", url, body_s)
-        return resp.json().get("guid", "No GUID Returned")
-
-    def create_project_task(
-        self,
-        project_guid: str,
-        display_name: str,
-        identifier: str = None,
-        description: str = None,
-        project_status: str = None,
-        project_phase: str = None,
-        project_health: str = None,
-        start_date: str = None,
-        planned_end_date: str = None,
-    ) -> str:
-        """Create a new project with the Task classification and link it to a project.
-
-        Parameters
-        ----------
-        project_guid: str
-            The unique identifier of the project to create the task for.The parent.
-        display_name: str
-            The display name of the element. Will also be used as the basis of the qualified_name.
-        identifier: str
-            A project identifier.
-        description: str
-            A description of the collection.
-        project_status: str, optional, defaults to "OTHER"
-            The project status
-        project_phase: str, optional
-            Project phase as defined in valid values
-        project_health: str, optional
-            Project health as defined in valid values
-        start_date: str, optional, defaults to None
-            Start date of the project in ISO 8601 string format.
-        planned_end_date: str, optional, defaults to None
-            Planned completion date in ISO 8601 string format.
-
-        Returns
-        -------
-        str - the guid of the created project task
-
-        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
-
-        """
-        loop = asyncio.get_event_loop()
-        resp = loop.run_until_complete(
-            self._async_create_project_task(
-                project_guid,
-                display_name,
-                identifier,
-                description,
-                project_status,
-                project_phase,
-                project_health,
-                start_date,
-                planned_end_date,
-            )
-        )
         return resp
 
+    @dynamic_catch
     async def _async_create_project_from_template(
-        self,
-        body: dict,
-    ) -> str:
+            self,
+            body: dict | TemplateRequestBody,
+            ) -> str:
         """Create a new metadata element to represent a project using an existing metadata element as a template.
         The template defines additional classifications and relationships that should be added to the new project.
         Async version.
@@ -1326,14 +963,13 @@ class ProjectManager(Client2):
         """
 
         url = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects/from-template"
-        body_s = body_slimmer(body)
-        resp = await self._async_make_request("POST", url, body_s)
-        return resp.json().get("guid", "No GUID Returned")
+        return await self._async_create_element_from_template(url, body)
 
+    @dynamic_catch
     def create_project_from_template(
-        self,
-        body: dict,
-    ) -> str:
+            self,
+            body: dict,
+            ) -> str:
         """Create a new metadata element to represent a project using an existing metadata element as a template.
         The template defines additional classifications and relationships that should be added to the new project.
 
@@ -1389,20 +1025,24 @@ class ProjectManager(Client2):
         resp = loop.run_until_complete(self._async_create_project_from_template(body))
         return resp
 
+    #
+    #
+    #
+
     async def _async_update_project(
-        self,
-        project_guid: str,
-        qualified_name: str = None,
-        identifier: str = None,
-        display_name: str = None,
-        description: str = None,
-        project_status: str = None,
-        project_phase: str = None,
-        project_health: str = None,
-        start_date: str = None,
-        planned_end_date: str = None,
-        replace_all_props: bool = False,
-    ) -> None:
+            self,
+            project_guid: str,
+            qualified_name: str = None,
+            identifier: str = None,
+            display_name: str = None,
+            description: str = None,
+            project_status: str = None,
+            project_phase: str = None,
+            project_health: str = None,
+            start_date: str = None,
+            planned_end_date: str = None,
+            replace_all_props: bool = False,
+            ) -> None:
         """Update the properties of a project. Async Version.
 
         Parameters
@@ -1461,25 +1101,25 @@ class ProjectManager(Client2):
             "projectHealth": project_health,
             "startDate": start_date,
             "plannedEndDate": planned_end_date,
-        }
+            }
         body_s = body_slimmer(body)
         await self._async_make_request("POST", url, body_s)
         return
 
     def update_project(
-        self,
-        project_guid: str,
-        qualified_name: str = None,
-        identifier: str = None,
-        display_name: str = None,
-        description: str = None,
-        project_status: str = None,
-        project_phase: str = None,
-        project_health: str = None,
-        start_date: str = None,
-        planned_end_date: str = None,
-        replace_all_props: bool = False,
-    ) -> None:
+            self,
+            project_guid: str,
+            qualified_name: str = None,
+            identifier: str = None,
+            display_name: str = None,
+            description: str = None,
+            project_status: str = None,
+            project_phase: str = None,
+            project_health: str = None,
+            start_date: str = None,
+            planned_end_date: str = None,
+            replace_all_props: bool = False,
+            ) -> None:
         """Update the properties of a project.
 
         Parameters
@@ -1534,14 +1174,14 @@ class ProjectManager(Client2):
                 start_date,
                 planned_end_date,
                 replace_all_props,
+                )
             )
-        )
         return
 
     async def _async_delete_project(
-        self,
-        project_guid: str, cascade: bool = False
-    ) -> None:
+            self,
+            project_guid: str, cascade: bool = False
+            ) -> None:
         """Delete a project.  It is detected from all parent elements. Async version
 
         Parameters
@@ -1577,9 +1217,9 @@ class ProjectManager(Client2):
         return
 
     def delete_project(
-        self,
-        project_guid: str, cascade: bool = False
-    ) -> None:
+            self,
+            project_guid: str, cascade: bool = False
+            ) -> None:
         """Delete a project.  It is detected from all parent elements.
 
         Parameters
@@ -1612,13 +1252,13 @@ class ProjectManager(Client2):
         return
 
     async def _async_add_to_project_team(
-        self,
-        project_guid: str,
-        actor_guid: str,
-        team_role: str = None,
-        effective_from: str = None,
-        effective_to: str = None,
-    ) -> None:
+            self,
+            project_guid: str,
+            actor_guid: str,
+            team_role: str = None,
+            effective_from: str = None,
+            effective_to: str = None,
+            ) -> None:
         """Add an actor to a project. The request body is optional.  If supplied, it contains the name of the role that
         the actor plays in the project. Async version.
 
@@ -1660,7 +1300,7 @@ class ProjectManager(Client2):
             "teamRole": team_role,
             "effectiveFrom": effective_from,
             "effectiveTo": effective_to,
-        }
+            }
         body_s = body_slimmer(body)
         if body_s is None:
             await self._async_make_request("POST", url)
@@ -1669,13 +1309,13 @@ class ProjectManager(Client2):
         return
 
     def add_to_project_team(
-        self,
-        project_guid: str,
-        actor_guid: str,
-        team_role: str = None,
-        effective_from: str = None,
-        effective_to: str = None,
-    ) -> None:
+            self,
+            project_guid: str,
+            actor_guid: str,
+            team_role: str = None,
+            effective_from: str = None,
+            effective_to: str = None,
+            ) -> None:
         """Add an actor to a project. The request body is optional.  If supplied, it contains the name of the role that
         the actor plays in the project.
 
@@ -1715,15 +1355,15 @@ class ProjectManager(Client2):
                 team_role,
                 effective_from,
                 effective_to,
+                )
             )
-        )
         return
 
     async def _async_remove_from_project_team(
-        self,
-        project_guid: str,
-        actor_guid: str,
-    ) -> None:
+            self,
+            project_guid: str,
+            actor_guid: str,
+            ) -> None:
         """Remove an actor from a project. Async version.
 
         Parameters
@@ -1759,10 +1399,10 @@ class ProjectManager(Client2):
         return
 
     def remove_from_project_team(
-        self,
-        project_guid: str,
-        actor_guid: str,
-    ) -> None:
+            self,
+            project_guid: str,
+            actor_guid: str,
+            ) -> None:
         """Remove an actor from a project.
 
         Parameters
@@ -1790,14 +1430,14 @@ class ProjectManager(Client2):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
             self._async_remove_from_project_team(project_guid, actor_guid)
-        )
+            )
         return
 
     async def _async_setup_project_management_role(
-        self,
-        project_guid: str,
-        project_role_guid: str,
-    ) -> None:
+            self,
+            project_guid: str,
+            project_role_guid: str,
+            ) -> None:
         """Create a ProjectManagement relationship between a project and a person role to show that anyone appointed to
         the role is a member of the project. Async version.
 
@@ -1835,10 +1475,10 @@ class ProjectManager(Client2):
         return
 
     def setup_project_management_role(
-        self,
-        project_guid: str,
-        project_role_guid: str,
-    ) -> None:
+            self,
+            project_guid: str,
+            project_role_guid: str,
+            ) -> None:
         """Create a ProjectManagement relationship between a project and a person role to show that anyone appointed to
         the role is a member of the project. Async version.
 
@@ -1868,14 +1508,14 @@ class ProjectManager(Client2):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
             self._async_setup_project_management_role(project_guid, project_role_guid)
-        )
+            )
         return
 
     async def _async_clear_project_management_role(
-        self,
-        project_guid: str,
-        project_role_guid: str,
-    ) -> None:
+            self,
+            project_guid: str,
+            project_role_guid: str,
+            ) -> None:
         """Remove a ProjectManagement relationship between a project and a person role. Async version.
 
         Parameters
@@ -1912,10 +1552,10 @@ class ProjectManager(Client2):
         return
 
     def clear_project_management_role(
-        self,
-        project_guid: str,
-        project_role_guid: str,
-    ) -> None:
+            self,
+            project_guid: str,
+            project_role_guid: str,
+            ) -> None:
         """Clear a ProjectManagement relationship between a project and a person role.
 
         Parameters
@@ -1944,7 +1584,7 @@ class ProjectManager(Client2):
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
             self._async_clear_project_management_role(project_guid, project_role_guid)
-        )
+            )
         return