pyegeria 5.4.7.6__py3-none-any.whl → 5.4.7.8__py3-none-any.whl

pyegeria/automated_curation.py

@@ -75,44 +75,35 @@ class AutomatedCuration(Client2):
         Extract properties from a technology type element and populate the provided columns_struct.
         Tolerant to missing fields.
         """
-        # Populate direct properties first
-        col_data = populate_columns_from_properties(element, columns_struct)
-        columns_list = col_data.get("formats", {}).get("columns", [])
-
-        # Referenceable header extraction (GUID, qualifiedName, displayName, etc.)
-        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")
+        # # Populate direct properties first
+        # col_data = populate_columns_from_properties(element, columns_struct)
+        # columns_list = col_data.get("formats", {}).get("columns", [])
+        #
+        # # Referenceable header extraction (GUID, qualifiedName, displayName, etc.)
+        # 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")
+        #
+        # # Try common category/type fields
+        # category = (
+        #     element.get("properties", {}).get("category")
+        #     or element.get("elementProperties", {}).get("category")
+        #     or element.get("elementType", {}).get("typeName")
+        #     or ""
+        # )
+        columns_list = columns_struct.get("formats", {}).get("columns", [])
+
+        guid = element.get('technologyTypeGUID',None)
+        qualified_name = element.get('qualifiedName',None)
+        display_name = element.get('displayName',None)
+        description = element.get('description',None)
+        catalog_templates = element.get('catalogTemplates',None)
+        external_references = element.get('externalReferences',None)
 
-        # Try common category/type fields
-        category = (
-            element.get("properties", {}).get("category")
-            or element.get("elementProperties", {}).get("category")
-            or element.get("elementType", {}).get("typeName")
-            or ""
-        )
-        for column in columns_list:
-            if column.get("key") in ("category", "type_name"):
-                column["value"] = category
-
-        # Classification names if present
-        class_names = []
-        for c in (element.get("elementHeader", {}).get("classifications") or []):
-            name = c.get("classificationName")
-            if name:
-                class_names.append(name)
-        if class_names:
-            for column in columns_list:
-                if column.get("key") == "classifications":
-                    column["value"] = ", ".join(class_names)
-                    break
-
-        # Relationship-driven fields (generic handling)
-        col_data = get_required_relationships(element, col_data)
 
         # Mermaid graph support if present
         mermaid_val = element.get("mermaidGraph", "") or ""
@@ -120,8 +111,33 @@ class AutomatedCuration(Client2):
             if column.get("key") == "mermaid":
                 column["value"] = mermaid_val
                 break
-
-        return col_data
+            elif column.get("key") == "catalog_template_specs":
+                specs = ""
+                for template in catalog_templates:
+                    for placeholder in template['specification']['placeholderProperty']:
+                        specs += (f"* Placeholder Property: {placeholder['placeholderPropertyName']}\n\t"
+                                  f"Type: {placeholder.get('dataType',"")}\n\t"
+                                  f"Description:  {placeholder.get('description',"")}\n\t"
+                                  f"Required: {placeholder.get("required","")}\n\t"
+                                  f"Example: {placeholder.get("example","")}\n\n")
+                column["value"] = specs
+            elif column.get("key") == "catalog_templates":
+                column["value"] =catalog_templates
+            elif column.get("key") == "guid":
+                column["value"] = guid
+            elif column.get("key") == "qualified_name":
+                column["value"] = qualified_name
+            elif column.get("key") == "display_name":
+                column["value"] = display_name
+            elif column.get("key") == "description":
+                column["value"] = description
+            elif column.get("key") == "external_references":
+                column["value"] = external_references
+            elif column.get("key") == "ref_url":
+                column["value"] = external_references[0]['relatedElement']['properties'].get('url',"")
+
+        columns_struct["formats"]["columns"] = columns_list
+        return columns_struct
 
     def _generate_tech_type_output(
         self,
@@ -3306,7 +3322,7 @@ class AutomatedCuration(Client2):
         )
         return response
 
-    async def _async_get_technology_type_detail(self, type_name: str, template_only: bool = False,
+    async def _async_get_technology_type_detail(self, type_name: str,
                                                 body: dict | FilterRequestBody = None,
                                                 output_format: str = "JSON",
                                                 output_format_set: str | dict = "TechType") -> list | str:
@@ -3316,13 +3332,9 @@ class AutomatedCuration(Client2):
         ----------
         type_name : str
             The name of the technology type to retrieve detailed information for.
-        template_only : bool
-            If true, only the template information will be returned.
         body: dict | FilterRequestBody
             If provided, the information in the body supersedes the other parameters and allows more advanced requests.
 
-
-
         Returns
         -------
         list[dict] | str
@@ -3356,27 +3368,24 @@ class AutomatedCuration(Client2):
         # validate_name(type_name)
         url = str(HttpUrl(f"{self.curation_command_root}/technology-types/by-name"))
         if body is None:
-            classified_elements = ["Template"] if template_only else []
             body = {
                 "class": "FilterRequestBody",
-                "filter": type_name,
-                "includeOnlyClassifiedElements": classified_elements,
+                "filter": type_name
             }
-        response = await self._async_get_name_request(
-            url,
-            _type=self.TECH_TYPE_ENTITY_LABEL,
-            _gen_output=self._generate_tech_type_output,
-            filter_string=type_name,
-            classification_names=classified_elements if template_only else None,
-            start_from=0,
-            page_size=0,
-            output_format=output_format,
-            output_format_set=output_format_set,
-            body=body,
-        )
-        return response
 
-    def get_technology_type_detail(self, type_name: str, template_only: bool = False,
+        response = await self._async_make_request("POST", url, body)
+        element = response.json().get("element", NO_ELEMENTS_FOUND)
+        if type(element) 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 self._generate_tech_type_output(element, type_name, "ValidMetadataValue",
+                               output_format, output_format_set)
+        return element
+
+    def get_technology_type_detail(self, type_name: str,
                                    body: dict | FilterRequestBody = None,
                                    output_format: str = "JSON",
                                    output_format_set: str | dict = "TechType") -> list | str:
@@ -3386,13 +3395,9 @@ class AutomatedCuration(Client2):
              ----------
              type_name : str
                  The name of the technology type to retrieve detailed information for.
-             template_only : bool
-                 If true, only the template information will be returned.
              body: dict | FilterRequestBody
                  If provided, the information in the body supersedes the other parameters and allows more advanced requests.
 
-
-
              Returns
              -------
              list[dict] | str
@@ -3425,7 +3430,7 @@ class AutomatedCuration(Client2):
 
         loop = asyncio.get_event_loop()
         response = loop.run_until_complete(
-            self._async_get_technology_type_detail(type_name, template_only=template_only, body=body,
+            self._async_get_technology_type_detail(type_name, body=body,
                                                    output_format=output_format,
                                                    output_format_set=output_format_set)
         )

pyegeria/collection_manager.py

@@ -209,7 +209,7 @@ class CollectionManager(Client2):
 
         url = (f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/collection-manager/"
                f"metadata-elements/{parent_guid}/collections")
-        return await self._async_get_name_request(url, body, output_format, output_format_set)
+
         response = await self._async_make_request("POST", url, body_slimmer(body))
         elements = response.json().get("elements", NO_ELEMENTS_FOUND)
         if type(elements) is str:

pyegeria/config.py

@@ -133,9 +133,9 @@ class DebugConfig(BaseModel):
 
 class LoggingConfig(BaseModel):
     """Logging configuration settings"""
-    console_filter_levels: List[str] = ["ERROR"]
-    console_logging_enabled: List[str] = ["_client_new", "_exceptions_new", "collections_manager_omvs", "tests"]
-    console_logging_level: str = "INFO"
+    console_filter_levels: List[str] = ["SUCCESS"]
+    console_logging_enabled: List[str] = ["_client_new", "_exceptions_new", "dr_egeria_md", "tests"]
+    console_logging_level: str = "ERROR"
     enable_logging: bool = False
     file_logging_level: str = "INFO"
     log_directory: str = "logs"

pyegeria/external_references.py

@@ -1403,7 +1403,7 @@ class ExternalReferences(Client2):
               The principle specified by the user_id does not have authorization for the requested action
         """
         url = str(HttpUrl(f"{self.command_root}/external-references/by-name"))
-        response = await self._async_get_name_request(url, _type="Collection",
+        response = await self._async_get_name_request(url, _type="ExternalReference",
                                                       _gen_output=self._generate_external_reference_output,
                                                       filter_string=filter_string,
                                                       classification_names=classification_names,