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

pyegeria/project_manager.py

@@ -8,33 +8,29 @@ 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)
+                             TemplateRequestBody, UpdateElementRequestBody, DeleteRequestBody,
+                             NewRelationshipRequestBody)
+from pyegeria.utils import body_slimmer, dynamic_catch
+from pyegeria._output_formats import select_output_format_set, get_output_format_type_match
 from pyegeria.output_formatter import (generate_output,
-                                       _extract_referenceable_properties, populate_columns_from_properties,
+                                       _extract_referenceable_properties,
+                                       populate_columns_from_properties,
                                        get_required_relationships)
-from pyegeria._client_new import Client2
-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"]
+PROJECT_PROPERTIES_LIST = ["ProjectProperties", "CampaignProperties", "StudyProjectProperties", "TaskProperties",
+                           "PersonalProjectProperties"]
+
 class ProjectManager(Client2):
     """
     Create and manage projects. Projects may be organized in a hierarchy.
@@ -54,33 +50,111 @@ 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 _extract_project_properties(self, element: dict, columns_struct: dict) -> dict:
+        """
+        Populate columns_struct values for a Project element using the standardized approach from collection_manager.
+        - Populate from element.properties
+        - Overlay header-derived values
+        - Derive classifications list
+        - Populate relationship-based columns generically
+        - Include mermaid graph if requested
+        """
+        col_data = populate_columns_from_properties(element, columns_struct)
+        columns_list = col_data.get("formats", {}).get("columns", [])
+
+        # Header-derived values
+        header_props = _extract_referenceable_properties(element)
+        for column in columns_list:
+            key = column.get('key')
+            if key in header_props:
+                column['value'] = header_props.get(key)
+            elif isinstance(key, str) and key.lower() == 'guid':
+                column['value'] = header_props.get('GUID')
+
+        # Classifications
+        cl_names = []
+        for c in element.get('elementHeader', {}).get('classifications', []) or []:
+            nm = c.get('classificationName')
+            if nm:
+                cl_names.append(nm)
+        if cl_names:
+            for column in columns_list:
+                if column.get('key') == 'classifications':
+                    column['value'] = ", ".join(cl_names)
+                    break
+
+        # Relationships
+        col_data = get_required_relationships(element, col_data)
+
+        # Mermaid
+        mermaid_val = element.get('mermaidGraph', "") or ""
+        for column in columns_list:
+            if column.get('key') == 'mermaid':
+                column['value'] = mermaid_val
+                break
+
+        return col_data
+
+    def _generate_project_output(self, elements: dict | list[dict], filter: str = None,
+                                 element_type_name: str | None = None,
+                                 output_format: str = 'DICT',
+                                 output_format_set: str | dict = None) -> str | list[dict]:
+        """
+        Generate output for projects using selectable output format sets.
+        """
+        entity_type = element_type_name or 'Project'
+
+        # Resolve output formats
+        if output_format_set:
+            if isinstance(output_format_set, str):
+                output_formats = select_output_format_set(output_format_set, output_format)
+            elif isinstance(output_format_set, dict):
+                output_formats = get_output_format_type_match(output_format_set, output_format)
+        elif element_type_name:
+            output_formats = select_output_format_set(element_type_name, output_format)
+        else:
+            output_formats = select_output_format_set(entity_type, output_format)
+        if output_formats is None:
+            output_formats = select_output_format_set('Default', output_format)
+
+        return generate_output(
+            elements,
+            filter,
+            entity_type,
+            output_format,
+            self._extract_project_properties,
+            None,
+            output_formats,
+        )
     #
     #       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,
+            filter_string: str = None,
+            classification_names: list[str] = None,
+            body: dict | FilterRequestBody = None,
+            start_from: int = 0, page_size: int = None,
+            output_format: str = "json", output_format_set: str | dict = 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.
 
@@ -116,83 +190,52 @@ class ProjectManager(Client2):
 
         """
 
-        if page_size is None:
-            page_size = self.page_size
-
-        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/"
-            f"metadata-elements/{parent_guid}/projects?startFrom={start_from}&pageSize={page_size}"
+            f"metadata-elements/{parent_guid}/projects"
         )
 
-        resp = await self._async_make_request("POST", url, body_s)
-        return resp.json().get("elements", "No linked projects found")
+        response = await self._async_get_name_request(url, _type="Project",
+                                                      _gen_output=self._generate_project_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
 
     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:
-        """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.
+            self,
+            parent_guid: str,
+            filter_string: str = None,
+            classification_names: list[str] = None,
+            body: dict | FilterRequestBody = None,
+            start_from: int = 0, page_size: int = None,
+            output_format: str = "json", output_format_set: str | dict = None,
+            ) -> list | str:
+        loop = asyncio.get_event_loop()
+        resp = loop.run_until_complete(
+            self._async_get_linked_projects(parent_guid, filter_string, classification_names,
+                                            body, start_from,page_size,output_format, output_format_set)
+            )
 
-        Parameters
-        ----------
-        parent_guid: str
-             The identity of the parent to find linked projects from
-        project_status: str, optional
-            Optionally, filter results by project status.
-        effective_time: str, optional
-            Time at which to query for projects. Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601).
+        return resp
 
-        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 projects linked off of the supplied element filtered by project status and effective time.
 
-        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_linked_projects(
-                parent_guid,
-                project_status,
-                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,
+            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:
         """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.
@@ -227,29 +270,31 @@ class ProjectManager(Client2):
 
         """
 
-        if page_size is None:
-            page_size = self.page_size
 
-        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/"
-            f"projects/by-classifications?startFrom={start_from}&pageSize={page_size}"
+            f"projects/by-classifications"
         )
+        response = await self._async_get_name_request(url, _type="Project",
+                                                      _gen_output=self._generate_project_output,
+                                                      filter_string=project_classification,
+                                                      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
 
-        resp = await self._async_make_request("POST", url, body_s)
-        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,
+            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:
         """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.
@@ -287,21 +332,24 @@ class ProjectManager(Client2):
         resp = loop.run_until_complete(
             self._async_get_classified_projects(
                 project_classification,
-                effective_time,
-                start_from,
+                classification_names,
+                body,   start_from,
                 page_size,
+                output_format,
+                output_format_set,
+                )
             )
-        )
         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,
+            classification_names: list[str] = None,
+            body: dict | FilterRequestBody = None,
+            start_from: int = 0, page_size: int = None,
+            output_format: str = "json", output_format_set: str | dict = 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.
@@ -339,29 +387,30 @@ class ProjectManager(Client2):
         -----
         """
 
-        if page_size is None:
-            page_size = self.page_size
 
-        body = {effective_time: effective_time, "filter": team_role}
-        body_s = body_slimmer(body)
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects/"
-            f"{project_guid}/team?startFrom={start_from}&pageSize={page_size}"
+            f"{project_guid}/team"
         )
+        response = await self._async_get_name_request(url, _type="Project",
+                                                      _gen_output=self._generate_project_output,
+                                                      filter_string=team_role,
+                                                      classification_names=classification_names,
+                                                      start_from=start_from, page_size=page_size,
+                                                      output_format=output_format, output_format_set=output_format_set,
+                                                      body=body)
 
-        resp = await self._async_make_request("POST", url, body_s)
-
-        result = resp.json().get("elements", NO_ELEMENTS_FOUND)
-        return result
+        return response
 
     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,
+            classification_names: list[str] = None,
+            body: dict | FilterRequestBody = None,
+            start_from: int = 0, page_size: int = None,
+            output_format: str = "json", output_format_set: str | dict = 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.
@@ -403,23 +452,27 @@ class ProjectManager(Client2):
             self._async_get_project_team(
                 project_guid,
                 team_role,
-                effective_time,
-                start_from,
+                classification_names,
+                body,   start_from,
                 page_size,
+                output_format,
+                output_format_set,
+                )
             )
-        )
         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 +514,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,293 +587,288 @@ 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="Project",
+                                                  _gen_output=self._generate_project_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.
+            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:
 
-        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
-
-        """
         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 project to retrieve.
+            element_type: str, optional, default = None
+                Metadata element type name to guide output formatting (defaults to "Project").
+            body: dict | GetRequestBody, optional, default = None
+                Full request body for advanced options (effective time, lineage, etc.).
+            output_format: str, optional, default = "JSON"
+                One of "DICT", "LIST", "MD", "FORM", "REPORT", "MERMAID" or "JSON".
+            output_format_set: str | dict, optional, default = None
+                The desired output columns/fields definition or a label referring to a predefined set.
+
+            Returns
+            -------
+            dict | str
+                JSON dict representing the specified project when output_format == "JSON";
+                otherwise a formatted string (or list) according to output_format.
+
+            Raises
+            ------
+            InvalidParameterException
+                If the client passes incorrect parameters on the request (bad URLs/values)
+            PropertyServerException
+                Raised by the server when an issue arises in processing a valid request
+            NotAuthorizedException
+                The requesting user is not authorized to issue this request
+
+            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 "Project"
 
-        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_project_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 project to retrieve.
+            element_type: str, optional, default = None
+                Metadata element type name to guide output formatting (defaults to "Project").
+            body: dict | GetRequestBody, optional, default = None
+                Full request body for advanced options (effective time, lineage, etc.).
+            output_format: str, optional, default = "JSON"
+                One of "DICT", "LIST", "MD", "FORM", "REPORT", "MERMAID" or "JSON".
+            output_format_set: str | dict, optional, default = None
+                The desired output columns/fields definition or a label referring to a predefined set.
+
+            Returns
+            -------
+            dict | str
+                JSON dict representing the specified project when output_format == "JSON";
+                otherwise a formatted string (or list) according to output_format.
+
+            Raises
+            ------
+            InvalidParameterException
+                If the client passes incorrect parameters on the request (bad URLs/values)
+            PropertyServerException
+                Raised by the server when an issue arises in processing a valid request
+            NotAuthorizedException
+                The requesting user is not authorized to issue this request
+
+            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:
-        """Return the mermaid graph of a specific project. Async version.
+            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 or formatted details 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.
-
+        project_guid: str
+            Unique identifier of the project.
+        element_type: str, optional, default = None
+            Metadata element type name to guide output formatting (defaults to "Project").
+        body: dict | GetRequestBody, optional, default = None
+            Full request body for advanced options (effective time, lineage, etc.).
+        output_format: str, optional, default = "JSON"
+            One of "DICT", "LIST", "MD", "FORM", "REPORT", "MERMAID" or "JSON".
+        output_format_set: str | dict, optional, default = None
+            The desired output columns/fields definition or a label referring to a predefined set.
 
         Returns
         -------
-         str
+        dict | str
+            JSON dict when output_format == "JSON"; otherwise a formatted string according to output_format
+            (for example, a Mermaid markdown string when output_format == "MERMAID").
 
-            A mermaid markdown string representing the graph of the project.
         Raises
         ------
-
         InvalidParameterException
-          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+            If the client passes incorrect parameters on the request (bad URLs/values)
         PropertyServerException
-          Raised by the server when an issue arises in processing a valid request
+            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
+            The requesting user is not authorized to issue this request
 
         """
 
-        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")
+
+        response = await self._async_get_guid_request(url, _type=element_type or 'Project',
+                                                      _gen_output=self._generate_project_output,
+                                                      output_format=output_format, output_format_set=output_format_set,
+                                                      body=body)
 
-    def get_project_graph(self, project_guid: str, effective_time: str = None) -> dict | str:
-        """Return the mermaid graph of a specific project.
+        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 or formatted details 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.
-
+        project_guid: str
+            Unique identifier of the project.
+        element_type: str, optional, default = None
+            Metadata element type name to guide output formatting (defaults to "Project").
+        body: dict | GetRequestBody, optional, default = None
+            Full request body for advanced options (effective time, lineage, etc.).
+        output_format: str, optional, default = "JSON"
+            One of "DICT", "LIST", "MD", "FORM", "REPORT", "MERMAID" or "JSON".
+        output_format_set: str | dict, optional, default = None
+            The desired output columns/fields definition or a label referring to a predefined set.
 
         Returns
         -------
-         str
+        dict | str
+            JSON dict when output_format == "JSON"; otherwise a formatted string according to output_format
+            (for example, a Mermaid markdown string when output_format == "MERMAID").
 
-            A mermaid markdown string representing the graph of the project.
         Raises
         ------
-
         InvalidParameterException
-          If the client passes incorrect parameters on the request - such as bad URLs or invalid values
+            If the client passes incorrect parameters on the request (bad URLs/values)
         PropertyServerException
-          Raised by the server when an issue arises in processing a valid request
+            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
+            The requesting user is not authorized to issue this request
 
         """
         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 +887,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,37 +914,27 @@ 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.
+        ----------
+        body: dict | NewElementRequestBody
+            A dict or NewElementRequestBody representing the details of the project to create.
 
         Returns
         -------
-        str - the guid of the created collection
+        str
+            The GUID of the created project.
 
         Raises
         ------
@@ -932,344 +971,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}"
-            )
-
-        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,
+            self._async_create_project(body)
             )
-        )
         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 +1036,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,50 +1098,28 @@ 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:
-        """Update the properties of a project. Async Version.
+            self,
+            project_guid: str,
+            body: dict | UpdateElementRequestBody,
+            ) -> None:
+        """Update the properties of a project. Async version.
 
         Parameters
         ----------
         project_guid: str
-            Unique identifier for the project.
-        qualified_name: str, optional, defaults to None
-            The unique identifier of the project.
-        identifier: str
-            A project identifier.
-        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.
-        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.
-        replace_all_props: bool, optional, defaults to False
-            If True, then all the properties of the project will be replaced with the specified properties.
+            Unique identifier of the project to update.
+        body: dict | UpdateElementRequestBody
+            The update payload specifying properties to change.
 
         Returns
         -------
-        str - the guid of the created project task
+        None
 
         Raises
         ------
@@ -1444,72 +1131,28 @@ class ProjectManager(Client2):
           The principle specified by the user_id does not have authorization for the requested action
         """
 
-        replace_all_props_s = str(replace_all_props).lower()
         url = (
-            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects/{project_guid}/"
-            f"update?replaceAllProperties={replace_all_props_s}"
+            f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects/{project_guid}/update"
         )
 
-        body = {
-            "class": "ProjectProperties",
-            "qualifiedName": qualified_name,
-            "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)
-        await self._async_make_request("POST", url, body_s)
-        return
+        await self._async_update_element_body_request(url, PROJECT_PROPERTIES_LIST, body)
 
     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,
+            body: dict | UpdateElementRequestBody            ) -> None:
         """Update the properties of a project.
 
         Parameters
         ----------
         project_guid: str
-            Unique identifier for the project.
-        qualified_name: str, optional, defaults to None
-            The unique identifier of the project.
-        identifier: str
-            A project identifier.
-        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.
-        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.
-        replace_all_props: bool, optional, defaults to False
-            If True, then all the properties of the project will be replaced with the specified properties.
+            Unique identifier of the project to update.
+        body: dict | UpdateElementRequestBody
+            The update payload specifying properties to change.
 
         Returns
         -------
-        str - the guid of the created project task
+        None
 
         Raises
         ------
@@ -1524,36 +1167,30 @@ class ProjectManager(Client2):
         loop.run_until_complete(
             self._async_update_project(
                 project_guid,
-                qualified_name,
-                identifier,
-                display_name,
-                description,
-                project_status,
-                project_phase,
-                project_health,
-                start_date,
-                planned_end_date,
-                replace_all_props,
+                body
+                )
             )
-        )
         return
 
     async def _async_delete_project(
-        self,
-        project_guid: str, cascade: bool = False
-    ) -> None:
-        """Delete a project.  It is detected from all parent elements. Async version
+            self,
+            project_guid: str, cascade_delete: bool = False,
+            body: dict | DeleteRequestBody = None
+            ) -> None:
+        """Delete a project. Async version.
 
         Parameters
         ----------
         project_guid: str
-            The guid of the project to update.
-        cascade: bool, optional, defaults to False
-            If true, then all anchored elements will be deleted.
+            The GUID of the project to delete.
+        cascade_delete: bool, optional, default = False
+            If True, then all anchored elements will be deleted.
+        body: dict | DeleteRequestBody, optional, default = None
+            Request body for additional options.
 
         Returns
         -------
-        Nothing
+        None
 
         Raises
         ------
@@ -1565,36 +1202,33 @@ class ProjectManager(Client2):
           The principle specified by the user_id does not have authorization for the requested action
 
         """
-        cascade_s = str(cascade).lower()
+
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects/"
-            f"{project_guid}/delete?cascadedDelete={cascade_s}"
+            f"{project_guid}/delete"
         )
-
-        body = {"class": "NullRequestBody"}
-
-        await self._async_make_request("POST", url, body)
-        return
+        await self._async_delete_request(url, body, cascade_delete)
+        logger.info(f"Deleted project {project_guid} with cascade {cascade_delete}")
 
     def delete_project(
-        self,
-        project_guid: str, cascade: bool = False
-    ) -> None:
-        """Delete a project.  It is detected from all parent elements.
+            self,
+            project_guid: str, cascade_delete: bool = False,
+            body: dict |DeleteRequestBody  = None
+            ) -> None:
+        """Delete a project.
 
         Parameters
         ----------
         project_guid: str
-            The guid of the collection to update.
-        cascade: bool, optional, defaults to False
-            If true, then all anchored elements will be deleted.
-
+            The GUID of the project to delete.
+        cascade_delete: bool, optional, default = False
+            If True, then all anchored elements will be deleted.
+        body: dict | DeleteRequestBody, optional, default = None
+            Request body for additional options.
 
-        cascade: bool, optional, defaults to False
-            If true, then all anchored elements will be deleted.
         Returns
         -------
-        Nothing
+        None
 
         Raises
         ------
@@ -1608,32 +1242,25 @@ class ProjectManager(Client2):
 
         """
         loop = asyncio.get_event_loop()
-        loop.run_until_complete(self._async_delete_project(project_guid, cascade))
-        return
+        loop.run_until_complete(self._async_delete_project(project_guid, cascade_delete, body))
+
 
     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:
-        """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.
+            self,
+            project_guid: str,
+            actor_guid: str,
+            body: dict | NewRelationshipRequestBody = None,
+            ) -> None:
+        """Add an actor to a project. Async version.
 
         Parameters
         ----------
         project_guid: str
-            identity of the project to update.
+            Identity of the project to update.
         actor_guid: str
-            identity of the actor to add.
-        team_role: str, optional, defaults to None
-            Name of the role the actor plays in the project.
-        effective_from: str, optional, defaults to None
-            Date at which the actor becomes active in the project. Date format is ISO 8601 string format.
-        effective_to: str, optional, defaults to None
-            Date at which the actor is no longer active in the project. Date format is ISO 8601 string format.
+            Identity of the actor to add.
+        body: dict | NewRelationshipRequestBody, optional, default = None
+            Optional relationship properties (for example, role name, effective times).
 
         Returns
         -------
@@ -1655,42 +1282,25 @@ class ProjectManager(Client2):
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects/{project_guid}/"
             f"members/{actor_guid}/attach"
         )
-        body = {
-            "class": "ProjectTeamProperties",
-            "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)
-        else:
-            await self._async_make_request("POST", url, body_s)
-        return
+        await self._async_new_relationship_request(url, "AssignmentScopeProperties", body)
+        logger.info(f"Added actor {actor_guid} to project {project_guid}")
 
     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:
-        """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.
+            self,
+            project_guid: str,
+            actor_guid: str,
+            body: dict | NewRelationshipRequestBody = None,
+            ) -> None:
+        """Add an actor to a project.
 
         Parameters
         ----------
         project_guid: str
-            identity of the project to update.
+            Identity of the project to update.
         actor_guid: str
-            identity of the actor to add.
-        team_role: str, optional, defaults to None
-            Name of the role the actor plays in the project.
-        effective_from: str, optional, defaults to None
-            Date at which the actor becomes active in the project. Date format is ISO 8601 string format.
-        effective_to: str, optional, defaults to None
-            Date at which the actor is no longer active in the project. Date format is ISO 8601 string format.
+            Identity of the actor to add.
+        body: dict | NewRelationshipRequestBody, optional, default = None
+            Optional relationship properties (for example, role name, effective times).
 
         Returns
         -------
@@ -1712,26 +1322,30 @@ class ProjectManager(Client2):
             self._async_add_to_project_team(
                 project_guid,
                 actor_guid,
-                team_role,
-                effective_from,
-                effective_to,
+                body
+                )
             )
-        )
-        return
+
 
     async def _async_remove_from_project_team(
-        self,
-        project_guid: str,
-        actor_guid: str,
-    ) -> None:
+            self,
+            project_guid: str,
+            actor_guid: str,
+            body: dict | DeleteRequestBody = None,
+            cascade_delete: bool = False,
+            ) -> None:
         """Remove an actor from a project. Async version.
 
         Parameters
         ----------
         project_guid: str
-            identity of the project to remove members from.
+            Identity of the project to remove members from.
         actor_guid: str
-            identity of the actor to remove.
+            Identity of the actor to remove.
+        body: dict | DeleteRequestBody, optional, default = None
+            Optional relationship properties.
+        cascade_delete: bool, optional, default = False
+            If True, deletes related anchored elements as applicable.
 
         Returns
         -------
@@ -1753,24 +1367,29 @@ class ProjectManager(Client2):
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects/{project_guid}/"
             f"members/{actor_guid}/detach"
         )
+        await self._async_delete_request(url, body, cascade_delete)
+        logger.info(f"Removed actor {actor_guid} from project {project_guid}")
 
-        body = {"class": "NullRequestBody"}
-        await self._async_make_request("POST", url, body)
-        return
 
     def remove_from_project_team(
-        self,
-        project_guid: str,
-        actor_guid: str,
-    ) -> None:
+            self,
+            project_guid: str,
+            actor_guid: str,
+            body: dict | DeleteRequestBody = None,
+            cascade_delete: bool = False,
+            ) -> None:
         """Remove an actor from a project.
 
         Parameters
         ----------
         project_guid: str
-            identity of the project.
+            Identity of the project.
         actor_guid: str
-            identity of the actor to remove.
+            Identity of the actor to remove.
+        body: dict | DeleteRequestBody, optional, default = None
+            Optional relationship properties.
+        cascade_delete: bool, optional, default = False
+            If True, deletes related anchored elements as applicable.
 
         Returns
         -------
@@ -1789,24 +1408,102 @@ class ProjectManager(Client2):
         """
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_remove_from_project_team(project_guid, actor_guid)
+            self._async_remove_from_project_team(project_guid, actor_guid, body, cascade_delete)
+            )
+
+
+    async def _async_setup_project_dependency(
+            self,
+            project_guid: str,
+            depends_on_project_guid: str,
+            body: dict | NewRelationshipRequestBody = None,
+            ) -> None:
+        """Create a project dependency link from one project to another. Async version.
+
+        Parameters
+        ----------
+        project_guid: str
+            Identity of the project that has the dependency.
+        depends_on_project_guid: str
+            GUID of the project that the first project depends on.
+
+
+        Returns
+        -------
+        None
+
+        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/{project_guid}/"
+            f"project-dependencies/{depends_on_project_guid}/attach"
         )
+        await self._async_new_relationship_request(url, "ProjectDependencyProperties", body)
+        logger.info(f"Added dependency between project  {project_guid} depending on project {depends_on_project_guid}")
+
+
+    def setup_project_dependency(
+            self,
+            project_guid: str,
+            depends_on_project_guid: str,
+            body: dict | NewRelationshipRequestBody = None,
+            ) -> None:
+        """Create a project dependency link from one project to another.
+
+        Parameters
+        ----------
+        project_guid: str
+            Identity of the project that has the dependency.
+        depends_on_project_guid: str
+            GUID of the project that the first project depends on.
+
+
+        Returns
+        -------
+        None
+
+        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()
+        loop.run_until_complete(
+            self._async_setup_project_dependency(   project_guid, depends_on_project_guid, body)
+            )
         return
 
-    async def _async_setup_project_management_role(
-        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.
+    async def _async_clear_project_dependency(
+            self,
+            project_guid: str,
+            depends_on_project_guid: str,
+            body: dict | DeleteRequestBody = None,
+            cascade_delete: bool = False
+            ) -> None:
+        """Remove a project dependency link between two projects. Async version.
 
         Parameters
         ----------
         project_guid: str
-            identity of the project.
-        project_role_guid: str
-            guid of the role to assign to the project.
+            Identity of the project that previously had the dependency.
+        depends_on_project_guid: str
+            GUID of the project that was depended on.
 
 
         Returns
@@ -1827,27 +1524,27 @@ class ProjectManager(Client2):
 
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects/{project_guid}/"
-            f"project-management-roles/{project_role_guid}/attach"
+            f"project-dependencies/{depends_on_project_guid}/detach"
         )
+        await self._async_delete_request(url, body, cascade_delete)
+        logger.info(f"Removed project dependency between project  {project_guid} and project {depends_on_project_guid}")
 
-        body = {"class": "NullRequestBody"}
-        await self._async_make_request("POST", url, body)
-        return
 
-    def setup_project_management_role(
-        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.
+    def clear_project_dependency(
+            self,
+            project_guid: str,
+            depends_on_project_guid: str,
+            body: dict | DeleteRequestBody = None,
+            cascade_delete: bool = False
+            ) -> None:
+        """Clear a project dependency link between two projects.
 
         Parameters
         ----------
         project_guid: str
-            identity of the project.
-        project_role_guid: str
-            guid of the role to assign to the project.
+            Identity of the project that previously had the dependency.
+        depends_on_project_guid: str
+            GUID of the project that was depended on.
 
 
         Returns
@@ -1867,23 +1564,25 @@ class ProjectManager(Client2):
         """
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_setup_project_management_role(project_guid, project_role_guid)
-        )
+            self._async_clear_project_dependency(project_guid, depends_on_project_guid,
+                                                 body, cascade_delete)
+            )
         return
 
-    async def _async_clear_project_management_role(
-        self,
-        project_guid: str,
-        project_role_guid: str,
-    ) -> None:
-        """Remove a ProjectManagement relationship between a project and a person role. Async version.
+    async def _async_setup_project_hierarchy(
+            self,
+            project_guid: str,
+            managed_project_guid: str,
+            body: dict | NewRelationshipRequestBody = None,
+            ) -> None:
+        """Create a project hierarchy link from a project to a managed (child) project. Async version.
 
         Parameters
         ----------
         project_guid: str
-            identity of the project.
-        project_role_guid: str
-            guid of the role to assign to the project.
+            Identity of the parent (managing) project.
+        managed_project_guid: str
+            GUID of the managed (child) project.
 
 
         Returns
@@ -1904,26 +1603,26 @@ class ProjectManager(Client2):
 
         url = (
             f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/project-manager/projects/{project_guid}/"
-            f"project-management-roles/{project_role_guid}/detach"
+            f"project-hierarchies/{managed_project_guid}/attach"
         )
+        await self._async_new_relationship_request(url, "ProjectHierarchyProperties", body)
+        logger.info(f"Added hierarchy between project  {project_guid} abd project {managed_project_guid}")
 
-        body = {"class": "NullRequestBody"}
-        await self._async_make_request("POST", url, body)
-        return
 
-    def clear_project_management_role(
-        self,
-        project_guid: str,
-        project_role_guid: str,
-    ) -> None:
-        """Clear a ProjectManagement relationship between a project and a person role.
+    def setup_project_hierarchy(
+            self,
+            project_guid: str,
+            managed_project_guid: str,
+            body: dict | NewRelationshipRequestBody = None,
+            ) -> None:
+        """Create a project hierarchy link from a project to a managed (child) project.
 
         Parameters
         ----------
         project_guid: str
-            identity of the project.
-        project_role_guid: str
-            guid of the role to assign to the project.
+            Identity of the parent (managing) project.
+        managed_project_guid: str
+            GUID of the managed (child) project.
 
 
         Returns
@@ -1943,10 +1642,102 @@ class ProjectManager(Client2):
         """
         loop = asyncio.get_event_loop()
         loop.run_until_complete(
-            self._async_clear_project_management_role(project_guid, project_role_guid)
+            self._async_setup_project_dependency(   project_guid, managed_project_guid, body)
+            )
+        return
+
+    async def _async_clear_project_hierarchy(
+            self,
+            project_guid: str,
+            managed_project_guid: str,
+            body: dict | DeleteRequestBody = None,
+            cascade_delete: bool = False
+            ) -> None:
+        """Remove a project hierarchy link between two projects. Async version.
+
+        Parameters
+        ----------
+        project_guid: str
+            Identity of the parent (managing) project.
+        managed_project_guid: str
+            GUID of the managed (child) project.
+
+
+        Returns
+        -------
+        None
+
+        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/{project_guid}/"
+            f"project-hierarchies/{managed_project_guid}/detach"
         )
+        await self._async_delete_request(url, body, cascade_delete)
+        logger.info(f"Removed project hierarchy link between project  {project_guid} and project {managed_project_guid}")
+
+
+    def clear_project_hierarchy(
+            self,
+            project_guid: str,
+            managed_project_guid: str,
+            body: dict | DeleteRequestBody = None,
+            cascade_delete: bool = False
+            ) -> None:
+        """Clear a project hierarchy link between two projects.
+
+        Parameters
+        ----------
+        project_guid: str
+            Identity of the parent (managing) project.
+        managed_project_guid: str
+            GUID of the managed (child) project.
+
+
+        Returns
+        -------
+        None
+
+        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()
+        loop.run_until_complete(
+            self._async_clear_project_hierarchy(project_guid, managed_project_guid,
+                                                 body, cascade_delete)
+            )
         return
 
 
 if __name__ == "__main__":
     print("Main-Project Manager")
+
+
+# Automatically apply @dynamic_catch to all methods of ProjectManager (excluding dunder methods)
+try:
+    for _name, _attr in list(ProjectManager.__dict__.items()):
+        if callable(_attr) and not _name.startswith("__"):
+            # Avoid double-wrapping if already decorated
+            if not getattr(_attr, "__wrapped__", None):
+                setattr(ProjectManager, _name, dynamic_catch(_attr))
+except Exception as _e:
+    # Be resilient; if anything goes wrong, leave methods as-is
+    logger.debug(f"dynamic_catch auto-wrap skipped due to: {_e}")