pyegeria 5.4.7.3__py3-none-any.whl → 5.4.7.5__py3-none-any.whl

pyegeria/_client_new.py

@@ -12,6 +12,7 @@ import inspect
 import json
 import os
 import re
+import sys
 from collections.abc import Callable
 from typing import Any
 
@@ -26,7 +27,7 @@ from pyegeria._exceptions_new import (
     PyegeriaAPIException, PyegeriaConnectionException, PyegeriaInvalidParameterException,
     PyegeriaUnknownException, PyegeriaClientException
 )
-from pyegeria._globals import enable_ssl_check, max_paging_size, NO_ELEMENTS_FOUND
+from pyegeria._globals import enable_ssl_check, max_paging_size, NO_ELEMENTS_FOUND, default_time_out
 from pyegeria._validators import (
     validate_name,
     validate_server_name,
@@ -34,9 +35,14 @@ from pyegeria._validators import (
     validate_user_id,
 )
 from pyegeria.models import (SearchStringRequestBody, FilterRequestBody, GetRequestBody, NewElementRequestBody,
-    TemplateRequestBody, UpdateStatusRequestBody, UpdateElementRequestBody, NewRelationshipRequestBody,
-    DeleteRequestBody, UpdateRelationshipRequestBody, ResultsRequestBody, NewClassificationRequestBody,
-    DeleteElementRequestBody, DeleteRelationshipRequestBody, DeleteClassificationRequestBody)
+                             TemplateRequestBody, UpdateStatusRequestBody, UpdateElementRequestBody,
+                             NewRelationshipRequestBody,
+                             DeleteRequestBody, UpdateRelationshipRequestBody, ResultsRequestBody,
+                             NewClassificationRequestBody,
+                             DeleteElementRequestBody, DeleteRelationshipRequestBody, DeleteClassificationRequestBody,
+                             LevelIdentifierQueryBody)
+
+from pyegeria.output_formatter import populate_common_columns, resolve_output_formats, generate_output
 from pyegeria.utils import body_slimmer, dynamic_catch
 
 ...
@@ -156,6 +162,8 @@ class Client2:
         self._template_request_adapter = TypeAdapter(TemplateRequestBody)
         self._update_relationship_request_adapter = TypeAdapter(UpdateRelationshipRequestBody)
         self._results_request_adapter = TypeAdapter(ResultsRequestBody)
+        self._level_identifier_query_body = TypeAdapter(LevelIdentifierQueryBody)
+
         try:
             result = self.check_connection()
             logger.info(f"client initialized, platform origin is: {result}")
@@ -203,7 +211,7 @@ class Client2:
         return
 
     async def _async_create_egeria_bearer_token(
-            self, user_id: str = None, password: str = None
+            self, user_id: str , password: str
     ) -> str:
         """Create and set an Egeria Bearer Token for the user. Async version
         Parameters
@@ -234,10 +242,8 @@ class Client2:
 
         """
         if user_id is None:
-            validate_user_id(self.user_id)
             user_id = self.user_id
         if password is None:
-            validate_name(self.user_pwd)
             password = self.user_pwd
 
         url = f"{self.platform_url}/api/token"
@@ -556,56 +562,6 @@ class Client2:
                     response, context, e=e
                 )
 
-    def build_global_guid_lists(self) -> None:
-        global template_guids, integration_guids
-
-        self.create_egeria_bearer_token(self.user_id, self.user_pwd)
-        # get all technology types
-        url = (
-            f"{self.platform_url}/servers/{self.server_name}/api/open-metadata/automated-curation/technology-types/"
-            f"by-search-string?startFrom=0&pageSize=0&startsWith=false&"
-            f"endsWith=false&ignoreCase=true"
-        )
-        body = {"filter": ""}
-
-        response = self.make_request("POST", url, body)
-        tech_types = response.json().get("elements", "no tech found")
-        if type(tech_types) is list:
-            for tech_type in tech_types:
-                # get tech type details
-                display_name = tech_type["name"]
-
-                url = (f"{self.platform_url}/servers/"
-                       f"{self.server_name}/api/open-metadata/automated-curation/technology-types/by-name")
-                body = {"filter": display_name}
-                response = self.make_request("POST", url, body)
-                details = response.json().get("element", "no type found")
-                if type(details) is str:
-                    continue
-                # get templates and update the template_guids global
-                templates = details.get("catalogTemplates", "Not Found")
-                if type(templates) is str:
-                    template_guids[display_name] = None
-                else:
-                    for template in templates:
-                        template_name = template.get("name", None)
-                        template_guid = template["relatedElement"]["guid"]
-                        template_guids[template_name] = template_guid
-                        # print(f"Added {template_name} template with GUID {template_guids[template_name]}")
-
-                # Now find the integration connector guids
-                resource_list = details.get("resourceList", " ")
-                if type(resource_list) is str:
-                    integration_guids[display_name] = None
-                else:
-                    for resource in resource_list:
-                        resource_guid = resource["relatedElement"]["guid"]
-                        resource_type = resource["relatedElement"]["type"]["typeName"]
-                        if resource_type == "IntegrationConnector":
-                            integration_guids[display_name] = resource_guid
-                            # print(f"Added {display_name} integration connector with GUID {integration_guids[
-                            # display_name]}")
-
     async def __async_get_guid__(
             self,
             guid: str = None,
@@ -639,7 +595,7 @@ class Client2:
             }
             url = (
                 f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/classification-manager/"
-                f"elements/guid-by-unique-name?forLineage=false&forDuplicateProcessing=false"
+                f"elements/guid-by-unique-name"
             )
 
             result = await self._async_make_request("POST", url, body_slimmer(body))
@@ -691,6 +647,9 @@ class Client2:
                                f"qualified_name={qualified_name}, tech_type={tech_type}")
             }
             raise PyegeriaInvalidParameterException(None, None, additional_info)
+    #
+    # Include basic functions for finding elements and relationships.
+    #
 
     def __get_guid__(
             self,
@@ -718,6 +677,11 @@ class Client2:
         )
         return result
 
+
+
+
+
+
     def __create_qualified_name__(self, type: str, display_name: str, local_qualifier: str = None,
                                   version_identifier: str = None) -> str:
         """Helper function to create a qualified name for a given type and display name.
@@ -734,10 +698,378 @@ class Client2:
             q_name = f"{q_name}::{version_identifier}"
         return q_name
 
-    async def _async_get_element_by_guid_(self, element_guid: str) -> dict | str:
+    async def _async_get_relationships_with_property_value(
+        self,
+        relationship_type: str,
+        property_value: str,
+        property_names: [str],
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        time_out: int = default_time_out,
+    ) -> list | str:
+        """
+        Retrieve relationships of the requested relationship type name and with the requested a value found in
+        one of the relationship's properties specified.  The value must match exactly. Async version.
+
+        https://egeria-project.org/types/
+
+        Parameters
+        ----------
+        relationship_type: str
+            - the type of relationship to navigate to related elements
+        property_value: str
+            - property value to be searched.
+        property_names: [str]
+            - property names to search in.
+        effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        start_from: int, default = 0
+            - index of the list to start from (0 for start).
+        page_size
+            - maximum number of elements to return.
+
+
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        [dict] | str
+            Returns a string if no elements found and a list of dict of elements with the results.
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+        """
+
+
+
+        body = {
+            "class": "FindPropertyNamesProperties",
+            "openMetadataType": relationship_type,
+            "propertyValue": property_value,
+            "propertyNames": property_names,
+            "effectiveTime": effective_time,
+        }
+
+        url = (
+            f"{self.platform_url}/servers/{self.server_name}/api/open-metadata/classification-manager/relationships/"
+            f"with-exact-property-value"
+        )
+
+        response: Response = await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+        rels = response.json().get("relationships", NO_ELEMENTS_FOUND)
+        if type(rels) is list:
+            if len(rels) == 0:
+                return NO_ELEMENTS_FOUND
+        return rels
+
+    def get_relationships_with_property_value(
+        self,
+        relationship_type: str,
+        property_value: str,
+        property_names: [str],
+        effective_time: str = None,
+        for_lineage: bool = None,
+        for_duplicate_processing: bool = None,
+        start_from: int = 0,
+        page_size: int = max_paging_size,
+        time_out: int = default_time_out,
+    ) -> list | str:
+        """
+        Retrieve relationships of the requested relationship type name and with the requested a value found in
+        one of the relationship's properties specified.  The value must match exactly.
+
+        Parameters
+        ----------
+        relationship_type: str
+            - the type of relationship to navigate to related elements
+        property_value: str
+            - property value to be searched.
+        property_names: [str]
+            - property names to search in.
+        effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        start_from: int, default = 0
+            - index of the list to start from (0 for start).
+        page_size
+            - maximum number of elements to return.
+
+
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        [dict] | str
+            Returns a string if no elements found and a list of dict of elements with the results.
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+        """
+
+        loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(
+            self._async_get_relationships_with_property_value(
+                relationship_type,
+                property_value,
+                property_names,
+                effective_time,
+                for_lineage,
+                for_duplicate_processing,
+                start_from,
+                page_size,
+                time_out,
+            )
+        )
+        return response
+
+
+    async def async_get_elements_by_property_value(
+            self,
+            property_value: str,
+            property_names: [str],
+            metadata_element_type_name: str = None,
+            effective_time: str = None,
+            for_lineage: bool = None,
+            for_duplicate_processing: bool = None,
+            start_from: int = 0,
+            page_size: int = 0,
+            time_out: int = default_time_out,
+    ) -> list | str:
+        """
+        Retrieve elements by a value found in one of the properties specified.  The value must match exactly.
+        An open metadata type name may be supplied to restrict the results. Async version.
+
+        https://egeria-project.org/types/
+
+        Parameters
+        ----------
+        property_value: str
+            - property value to be searched.
+        property_names: [str]
+            - property names to search in.
+        metadata_element_type_name : str, default = None
+            - open metadata type to be used to restrict the search
+        effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        start_from: int, default = 0
+            - index of the list to start from (0 for start).
+        page_size
+            - maximum number of elements to return.
+
+
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        [dict] | str
+            Returns a string if no elements found and a list of dict of elements with the results.
+
+        Raises
+        ------
+        PyegeriaException
+        """
+
+        body = {
+            "class": "FindPropertyNamesProperties",
+            "metadataElementTypeName": metadata_element_type_name,
+            "propertyValue": property_value,
+            "propertyNames": property_names,
+            "effectiveTime": effective_time,
+            "startFrom": start_from,
+            "pageSize": page_size,
+            "forLineage": for_lineage,
+            "forDuplicateProcessing": for_duplicate_processing
+        }
+
+        url = f"{self.platform_url}/servers/{self.server_name}/api/open-metadata/classification-explorer/elements/by-exact-property-value"
+
+        response: Response = await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+
+        elements = response.json().get("elements", NO_ELEMENTS_FOUND)
+        if type(elements) is list:
+            if len(elements) == 0:
+                return NO_ELEMENTS_FOUND
+        return elements
+
+    def get_elements_by_property_value(
+            self,
+            property_value: str,
+            property_names: [str],
+            metadata_element_type_name: str = None,
+            effective_time: str = None,
+            for_lineage: bool = None,
+            for_duplicate_processing: bool = None,
+            start_from: int = 0,
+            page_size: int = 0,
+            time_out: int = default_time_out,
+            output_format: str = "JSON",
+            output_format_set: dict | str = None,
+    ) -> list | str:
+        """
+        Retrieve elements by a value found in one of the properties specified.  The value must match exactly.
+        An open metadata type name may be supplied to restrict the results.
+
+        https://egeria-project.org/types/
+
+        Parameters
+        ----------
+        property_value: str
+            - property value to be searched.
+        property_names: [str]
+            - property names to search in.
+        metadata_element_type_name : str, default = None
+            - open metadata type to be used to restrict the search
+        effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        start_from: int, default = 0
+            - index of the list to start from (0 for start).
+        page_size
+            - maximum number of elements to return.
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+        output_format: str, default = "JSON"
+            - Type of output to return.
+        output_format_set: dict | str, default = None
+            - Output format set to use. If None, the default output format set is used.
+
+        Returns
+        -------
+        [dict] | str
+            Returns a string if no elements found and a list of dict of elements with the results.
+
+        Raises
+        ------
+        PyegeriaException.
+        """
+
+        loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(
+            self.async_get_elements_by_property_value(
+                property_value,
+                property_names,
+                metadata_element_type_name,
+                effective_time,
+                for_lineage,
+                for_duplicate_processing,
+                start_from,
+                page_size,
+                time_out,
+            )
+        )
+        return response
+
+    async def async_get_guid_for_name(
+            self, name: str, property_name: [str] = ["qualifiedName","displayName"], type_name: str = "ValidMetadataValue"
+
+    ) -> list | str:
+        """
+        Retrieve the guid associated with the supplied element name.
+        If more than one element returned, an exception is thrown. Async version.
+
+        Parameters
+        ----------
+        name: str
+            - element name to be searched.
+        property_name: [str], default = ["qualifiedName","displayName"]
+            - propertys to search in.
+        type_name: str, default = "ValidMetadataValue"
+            - metadata element type name to be used to restrict the search
+        Returns
+        -------
+        str
+            Returns the guid of the element.
+
+        Raises
+        ------
+        PyegeriaException
+        """
+
+        elements = await self.async_get_elements_by_property_value(
+            name, property_name, type_name
+        )
+
+        if type(elements) is list:
+            if len(elements) == 0:
+                return NO_ELEMENTS_FOUND
+            elif len(elements) > 1:
+                raise Exception("Multiple elements found for supplied name!")
+            elif len(elements) == 1:
+                return elements[0]["elementHeader"]["guid"]
+        return elements
+
+    def get_guid_for_name(
+            self, name: str, property_name: [str] = ["qualifiedName","displayName"], type_name: str = "ValidMetadataValue"
+    ) -> list | str:
         """
-        Simplified, internal version of get_element_by_guid found in Classification Manager.
-        Retrieve an element by its guid.  Async version.
+        Retrieve the guid associated with the supplied element name.
+        If more than one element returned, an exception is thrown.
+
+        Parameters
+        ----------
+        name: str
+            - element name to be searched.
+        property_name: [str], default = ["qualifiedName","displayName"]
+            - propertys to search in.
+        type_name: str, default = "ValidMetadataValue"
+            - metadata element type name to be used to restrict the search
+        Returns
+        -------
+        str
+            Returns the guid of the element.
+
+        Raises
+        ------
+        PyegeriaExeception
+        """
+
+        loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(
+            self.async_get_guid_for_name(name, property_name, type_name)
+        )
+        return response
+
+
+    async def async_get_element_by_guid_(self, element_guid: str) -> dict | str:
+        """
+            Simplified, internal version of get_element_by_guid found in Classification Manager.
+            Retrieve an element by its guid.  Async version.
 
         Parameters
         ----------
@@ -764,7 +1096,7 @@ class Client2:
             "effectiveTime": None,
         }
 
-        url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/classification-manager/elements/"
+        url = (f"{self.platform_url}/servers/{self.server_name}/api/open-metadata/classification-manager/elements/"
                f"{element_guid}?forLineage=false&forDuplicateProcessing=false")
 
         response: Response = await self._async_make_request("POST", url, body_slimmer(body))
@@ -773,6 +1105,210 @@ class Client2:
 
         return elements
 
+    async def async_get_related_elements_with_property_value(
+            self,
+            element_guid: str,
+            relationship_type: str,
+            property_value: str,
+            property_names: [str],
+            metadata_element_type_name: str = None,
+            start_at_end: int = 1,
+            effective_time: str = None,
+            for_lineage: bool = None,
+            for_duplicate_processing: bool = None,
+            start_from: int = 0,
+            page_size: int = 0,
+            time_out: int = default_time_out,
+    ) -> list | str:
+        """
+        Retrieve elements linked via the requested relationship type name and with the requested a value found in one of
+        the classification's properties specified.  The value must match exactly. An open metadata type name may be
+        supplied to restrict the types of elements returned. Async version.
+
+        https://egeria-project.org/types/
+
+        Parameters
+        ----------
+        element_guid: str
+            - the base element to get related elements for
+        relationship_type: str
+            - the type of relationship to navigate to related elements
+        property_value: str
+            - property value to be searched.
+        property_names: [str]
+            - property names to search in.
+        metadata_element_type_name : str, default = None
+            - restrict search to elements of this open metadata type
+        start_at_end: int, default = 1
+            - The end of the relationship to start from - typically End1
+            - open metadata type to be used to restrict the search
+        effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        start_from: int, default = 0
+            - index of the list to start from (0 for start).
+        page_size
+            - maximum number of elements to return.
+
+
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        [dict] | str
+            Returns a string if no elements found and a list of dict of elements with the results.
+
+        Raises
+        ------
+        PyegeriaException
+        """
+
+        body = {
+            "class": "FindPropertyNamesProperties",
+            "metadataElementTypeName": metadata_element_type_name,
+            "propertyValue": property_value,
+            "propertyNames": property_names,
+            "effectiveTime": effective_time,
+            "forLineage": for_lineage,
+            "forDuplicateProcessing": for_duplicate_processing,
+            "startFrom": start_from,
+            "pageSize": page_size
+        }
+
+        url = (
+             f"{self.platform_url}/servers/{self.server_name}/api/open-metadata/classification-explorer/elements/{element_guid}"
+             f"/by-relationship/{relationship_type}/with-exact-property-value?startAtEnd={start_at_end}"
+        )
+
+        response: Response = await self._async_make_request(
+            "POST", url, body_slimmer(body), time_out=time_out
+        )
+        elements = response.json().get("elements", NO_ELEMENTS_FOUND)
+        if type(elements) is list:
+            if len(elements) == 0:
+                return NO_ELEMENTS_FOUND
+        return elements
+
+    def get_relationships_with_property_value(
+            self,
+            relationship_type: str,
+            property_value: str,
+            property_names: [str],
+            effective_time: str = None,
+            for_lineage: bool = None,
+            for_duplicate_processing: bool = None,
+            start_from: int = 0,
+            page_size: int = max_paging_size,
+            time_out: int = default_time_out,
+    ) -> list | str:
+        """
+        Retrieve relationships of the requested relationship type name and with the requested a value found in
+        one of the relationship's properties specified.  The value must match exactly.
+
+        Parameters
+        ----------
+        relationship_type: str
+            - the type of relationship to navigate to related elements
+        property_value: str
+            - property value to be searched.
+        property_names: [str]
+            - property names to search in.
+        effective_time: str, default = None
+            - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
+        for_lineage: bool, default is set by server
+            - determines if elements classified as Memento should be returned - normally false
+        for_duplicate_processing: bool, default is set by server
+            - Normally false. Set true when the caller is part of a deduplication function
+        start_from: int, default = 0
+            - index of the list to start from (0 for start).
+        page_size
+            - maximum number of elements to return.
+
+
+        time_out: int, default = default_time_out
+            - http request timeout for this request
+
+        Returns
+        -------
+        [dict] | str
+            Returns a string if no elements found and a list of dict of elements with the results.
+
+        Raises
+        ------
+        InvalidParameterException
+            one of the parameters is null or invalid or
+        PropertyServerException
+            There is a problem adding the element properties to the metadata repository or
+        UserNotAuthorizedException
+            the requesting user is not authorized to issue this request.
+        """
+
+        loop = asyncio.get_event_loop()
+        response = loop.run_until_complete(
+            self._async_get_relationships_with_property_value(
+                relationship_type,
+                property_value,
+                property_names,
+                effective_time,
+                for_lineage,
+                for_duplicate_processing,
+                start_from,
+                page_size,
+                time_out,
+            )
+        )
+        return response
+
+    async def async_get_connector_guid(self, connector_name: str) -> str:
+        """Get the guid of a connector. Async version.
+            Parameters:
+                connector_name (str): The name of the connector to retrieve the guid for.
+            Returns:
+                str: The guid of the connector.
+        """
+        rel = await self._async_get_relationships_with_property_value(relationship_type="RegisteredIntegrationConnector",
+                                                             property_names=["connectorName"],
+                                                             property_value=connector_name,
+                                                             )
+        if rel == "No elements found":
+            logger.error(f"\n\n===> No connector found with name '{connector_name}'\n\n")
+            return "No connector found"
+        connector_guid = rel[0]['end2']['guid']
+
+        if connector_guid is None:
+            logger.error(f"\n\n===> No connector found with name '{connector_name}'\n\n")
+            return "No connector found"
+
+        return connector_guid
+
+
+    def get_connector_guid(self, connector_name: str) -> str:
+        """Get the guid of a connector.
+            Parameters:
+                connector_name (str): The name of the connector to retrieve the guid for.
+            Returns:
+                str: The guid of the connector.
+        """
+
+        loop = asyncio.get_event_loop()
+        result = loop.run_until_complete(
+            self.async_get_connector_guid(
+                connector_name
+            )
+        )
+        return result
+
+
+
+    #
+    # Helper functions for requests
+    #
+
+
     def validate_new_element_request(self, body: dict | NewElementRequestBody,
                                      prop: list[str]) -> NewElementRequestBody | None:
         if isinstance(body, NewElementRequestBody):
@@ -1029,7 +1565,7 @@ class Client2:
         json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
 
         response = await self._async_make_request("POST", url, json_body)
-        elements = response.json().get("elements", NO_ELEMENTS_FOUND)
+        elements = response.json().get("element", NO_ELEMENTS_FOUND)
         if type(elements) is str:
             logger.info(NO_ELEMENTS_FOUND)
             return NO_ELEMENTS_FOUND
@@ -1101,6 +1637,35 @@ class Client2:
                                output_format, output_format_set)
         return elements
 
+    async def _async_get_level_identifier_query_body_request(self, url: str, _gen_output: Callable[..., Any],
+                                              output_format: str = 'JSON',
+                                              output_format_set: str | dict = None,
+                                              body: dict | ResultsRequestBody = None) -> Any:
+        if isinstance(body, LevelIdentifierQueryBody):
+            validated_body = body
+        elif isinstance(body, dict):
+            validated_body = self._level_identifier_query_body.validate_python(body)
+        else:
+            return None
+
+        json_body = validated_body.model_dump_json(indent=2, exclude_none=True)
+
+        response = await self._async_make_request("POST", url, json_body)
+        elements = response.json().get("elements", None)
+        if elements is None:
+            elements = response.json().get("element", NO_ELEMENTS_FOUND)
+
+        if type(elements) is str:
+            logger.info(NO_ELEMENTS_FOUND)
+            return NO_ELEMENTS_FOUND
+
+        if output_format != 'JSON':  # return a simplified markdown representation
+            logger.info(f"Found elements, output format: {output_format} and output_format_set: {output_format_set}")
+            return _gen_output(elements, "", "Referenceable",
+                               output_format, output_format_set)
+        return elements
+
+
     async def _async_create_element_body_request(self, url: str, prop: list[str],
                                                  body: dict | NewElementRequestBody = None) -> str:
         validated_body = self.validate_new_element_request(body, prop)
@@ -1633,4 +2198,33 @@ class Client2:
     #             }
     #            """
     #         loop = asyncio.get_event_loop()
-    #         loop.run_until_complete(self._async_update_element_status(guid, status, body))
+    #         loop.run_until_complete(self._async_update_element_status(guid, status, body))
+
+    @dynamic_catch
+    def _extract_referenceable_properties(self, element: dict, columns_struct: dict) -> dict:
+        """Populate default Referenceable columns for output using common population pipeline."""
+        return populate_common_columns(element, columns_struct)
+
+    @dynamic_catch
+    def _generate_referenceable_output(self, elements: dict | list[dict], search_string: str | None,
+                                       element_type_name: str | None,
+                                       output_format: str = "JSON",
+                                       output_format_set: dict | str = None) -> str | list[dict]:
+        """Generate formatted output for generic Referenceable elements.
+
+        If output_format is 'JSON', returns elements unchanged. Otherwise, resolves an
+        output format set and delegates to generate_output with a standard extractor.
+        """
+        if output_format == "JSON":
+            return elements
+        entity_type = element_type_name or "Referenceable"
+        output_formats = resolve_output_formats(entity_type, output_format, output_format_set, default_label=entity_type)
+        return generate_output(
+            elements=elements,
+            search_string=search_string,
+            entity_type=entity_type,
+            output_format=output_format,
+            extract_properties_func=self._extract_referenceable_properties,
+            get_additional_props_func=None,
+            columns_struct=output_formats,
+        )