pyegeria 5.4.0.28__py3-none-any.whl → 5.5.3.3__py3-none-any.whl

examples/format_sets_save_load_example.py

@@ -0,0 +1,291 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+Example script demonstrating how to save and load report specs (formerly called format sets).
+
+This script shows how to:
+1. Create custom report specs
+2. Save report specs to a file
+3. Load report specs from a file
+4. Use the loaded report specs
+5. Work with the user report specs directory
+"""
+
+import sys
+import os
+
+# Add the parent directory to the path so we can import the modules
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from pyegeria.view._output_format_models import Column, Format, ActionParameter, FormatSet, FormatSetDict
+from pyegeria.view.base_report_formats import (
+    report_specs,
+    save_report_specs,
+    USER_FORMAT_SETS_DIR,
+    select_report_spec,
+)
+
+def create_custom_format_sets():
+    """
+    Create custom report specs for the example.
+    
+    Returns:
+        FormatSetDict: A dictionary of custom format sets
+    """
+    print("\n=== Creating Custom Report Specs ===")
+    
+    # Create common columns that will be used in multiple formats
+    common_columns = [
+        Column(name="ID", key="id"),
+        Column(name="Name", key="name"),
+        Column(name="Description", key="description", format=True),
+    ]
+    
+    # Create additional columns for specific formats
+    detail_columns = [
+        Column(name="Created By", key="created_by"),
+        Column(name="Created Date", key="created_date"),
+        Column(name="Modified By", key="modified_by"),
+        Column(name="Modified Date", key="modified_date"),
+    ]
+    
+    technical_columns = [
+        Column(name="Type", key="type"),
+        Column(name="Status", key="status"),
+        Column(name="Version", key="version"),
+    ]
+    
+    # Create formats that reuse and compose columns
+    table_format = Format(
+        types=["TABLE"],
+        columns=common_columns,  # Basic columns for table view
+    )
+    
+    detail_format = Format(
+        types=["DETAIL", "FORM"],
+        columns=common_columns + detail_columns,  # Common columns plus detail columns
+    )
+    
+    technical_format = Format(
+        types=["TECHNICAL", "DICT"],
+        columns=common_columns + technical_columns,  # Common columns plus technical columns
+    )
+    
+    full_format = Format(
+        types=["FULL", "REPORT"],
+        columns=common_columns + detail_columns + technical_columns,  # All columns
+    )
+    
+    # Create format sets that include the formats
+    product_format_set = FormatSet(
+        heading="Product Format Set",
+        description="A format set for product information",
+        aliases=["Product", "Products"],
+        formats=[table_format, detail_format, technical_format],
+        action=[
+            ActionParameter(
+                function="ProductManager.find_products",
+                required_params=["search_string"],
+                spec_params={},
+            )
+        ],
+    )
+    
+    customer_format_set = FormatSet(
+        heading="Customer Format Set",
+        description="A format set for customer information",
+        aliases=["Customer", "Customers"],
+        formats=[table_format, detail_format, full_format],
+        action=[
+            ActionParameter(
+                function="CustomerManager.find_customers",
+                required_params=["search_string"],
+                spec_params={},
+            )
+        ],
+    )
+    
+    # Create a FormatSetDict with the custom format sets
+    custom_format_sets = FormatSetDict({
+        "Product": product_format_set,
+        "Customer": customer_format_set,
+    })
+    
+    print(f"Created {len(custom_format_sets)} custom format sets:")
+    for name, format_set in custom_format_sets.items():
+        print(f"  - {name}: {format_set.heading}")
+        print(f"    Description: {format_set.description}")
+        print(f"    Aliases: {format_set.aliases}")
+        print(f"    Number of formats: {len(format_set.formats)}")
+    
+    return custom_format_sets
+
+def save_format_sets_example(custom_format_sets):
+    """
+    Example of saving report specs to a file.
+    
+    Args:
+        custom_format_sets: The custom report specs to save
+    
+    Returns:
+        str: The path to the saved file
+    """
+    print("\n=== Saving Report Specs ===")
+    
+    # Create a directory for the example files
+    example_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), "format_sets")
+    os.makedirs(example_dir, exist_ok=True)
+    
+    # Save all format sets to a file
+    all_format_sets_path = os.path.join(example_dir, "all_format_sets.json")
+    save_report_specs(all_format_sets_path)
+    print(f"Saved all report specs to {all_format_sets_path}")
+    
+    # Save only the custom format sets to a file
+    custom_format_sets_path = os.path.join(example_dir, "custom_format_sets.json")
+    custom_format_sets.save_to_json(custom_format_sets_path)
+    print(f"Saved custom report specs to {custom_format_sets_path}")
+    
+    # Save a subset of the predefined format sets to a file
+    subset_format_sets_path = os.path.join(example_dir, "subset_format_sets.json")
+    save_report_specs(subset_format_sets_path, format_set_names=["Collections", "DataDictionary"])
+    print(f"Saved subset of report specs to {subset_format_sets_path}")
+    
+    return custom_format_sets_path
+
+def load_format_sets_example(file_path):
+    """
+    Example of loading report specs from a file.
+    
+    Args:
+        file_path: The path to the file to load
+    
+    Returns:
+        FormatSetDict: The loaded report specs
+    """
+    print("\n=== Loading Report Specs ===")
+    
+    # Create a new FormatSetDict to load the report specs into
+    loaded_format_sets = FormatSetDict()
+    
+    # Load the report specs from the file
+    try:
+        loaded_format_sets = FormatSetDict.load_from_json(file_path)
+        print(f"Loaded {len(loaded_format_sets)} report specs from {file_path}")
+        
+        # Print information about the loaded report specs
+        for name, format_set in loaded_format_sets.items():
+            print(f"  - {name}: {format_set.heading}")
+            print(f"    Description: {format_set.description}")
+            print(f"    Aliases: {format_set.aliases}")
+            print(f"    Number of formats: {len(format_set.formats)}")
+        
+        return loaded_format_sets
+    except Exception as e:
+        print(f"Error loading report specs from {file_path}: {e}")
+        return None
+
+def use_loaded_format_sets(loaded_format_sets):
+    """
+    Example of using loaded report specs.
+    
+    Args:
+        loaded_format_sets: The loaded report specs to use
+    """
+    print("\n=== Using Loaded Report Specs ===")
+    
+    # Add the loaded format sets to the global report_specs
+    for name, format_set in loaded_format_sets.items():
+        report_specs[name] = format_set
+    
+    # Use the select_report_spec function to get a report spec by name
+    product_format_set = select_report_spec("Product", "TABLE")
+    if product_format_set:
+        print(f"Found report spec for 'Product' with output type 'TABLE'")
+        print(f"  Heading: {product_format_set['heading']}")
+        print(f"  Description: {product_format_set['description']}")
+        print(f"  Number of columns: {len(product_format_set['formats']['columns'])}")
+    else:
+        print("Format set for 'Product' not found")
+    
+    # Use the select_report_spec function to get a report spec by alias
+    customer_format_set = select_report_spec("Customers", "DETAIL")
+    if customer_format_set:
+        print(f"Found report spec for 'Customers' with output type 'DETAIL'")
+        print(f"  Heading: {customer_format_set['heading']}")
+        print(f"  Description: {customer_format_set['description']}")
+        print(f"  Number of columns: {len(customer_format_set['formats']['columns'])}")
+    else:
+        print("Format set for 'Customers' not found")
+
+def user_format_sets_directory_example(custom_format_sets):
+    """
+    Example of working with the user report specs directory.
+    
+    Args:
+        custom_format_sets: The custom report specs to save to the user directory
+    """
+    print("\n=== Working with User Report Specs Directory ===")
+    
+    # Create the user report specs directory if it doesn't exist
+    os.makedirs(USER_FORMAT_SETS_DIR, exist_ok=True)
+    print(f"User report specs directory: {USER_FORMAT_SETS_DIR}")
+    
+    # Save a custom report spec to the user directory
+    user_format_set = FormatSet(
+        heading="User Custom Format Set",
+        description="A custom format set for the user directory",
+        formats=[
+            Format(
+                types=["TABLE"],
+                columns=[
+                    Column(name="Column 1", key="column1"),
+                    Column(name="Column 2", key="column2"),
+                ],
+            ),
+        ],
+    )
+    
+    user_format_sets = FormatSetDict({"UserCustomFormatSet": user_format_set})
+    user_format_sets_path = os.path.join(USER_FORMAT_SETS_DIR, "user_custom_format_sets.json")
+    user_format_sets.save_to_json(user_format_sets_path)
+    print(f"Saved user custom report spec to {user_format_sets_path}")
+    
+    # Load the user format sets
+    from pyegeria.view.base_report_formats import load_user_report_specs
+    load_user_report_specs()
+    
+    # Check if the user report spec was loaded
+    if "UserCustomFormatSet" in report_specs:
+        print("User custom report spec was successfully loaded")
+        print(f"  Heading: {report_specs['UserCustomFormatSet'].heading}")
+        print(f"  Description: {report_specs['UserCustomFormatSet'].description}")
+    else:
+        print("User custom report spec was not loaded")
+
+def main():
+    """Run the example."""
+    print("=== Report Specs Save/Load Example ===")
+    
+    # Create custom format sets
+    custom_format_sets = create_custom_format_sets()
+    
+    # Save format sets to files
+    file_path = save_format_sets_example(custom_format_sets)
+    
+    # Load format sets from a file
+    loaded_format_sets = load_format_sets_example(file_path)
+    
+    # Use the loaded format sets
+    if loaded_format_sets:
+        use_loaded_format_sets(loaded_format_sets)
+    
+    # Work with the user format sets directory
+    user_format_sets_directory_example(custom_format_sets)
+    
+    print("\n=== Example Complete ===")
+
+if __name__ == "__main__":
+    main()

examples/jacquard_data_sets.py

@@ -0,0 +1,129 @@
+"""
+PDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+This module contains the Jacquard Data Sets View Service client.
+"""
+
+import asyncio
+
+from pyegeria.core._server_client import ServerClient
+from pyegeria.models import (
+    SearchStringRequestBody,
+)
+from pyegeria.core.utils import dynamic_catch
+
+
+class JacquardDataSets(ServerClient):
+    """
+    Client for the Jacquard Data Sets View Service.
+
+    The Jacquard Data Sets View Service provides methods to manage and retrieve tabular data sets.
+    Note: Many of these methods are implemented in the Data Engineer View Service.
+
+    Attributes
+    ----------
+    view_server : str
+        The name of the View Server to use.
+    platform_url : str
+        URL of the server platform to connect to.
+    user_id : str
+        The identity of the user calling the method.
+    user_pwd : str
+        The password associated with the user_id. Defaults to None.
+    """
+
+    def __init__(
+        self,
+        view_server: str,
+        platform_url: str,
+        user_id: str,
+        user_pwd: str = None,
+        token: str = None,
+    ):
+        super().__init__(view_server, platform_url, user_id, user_pwd, token)
+        self.view_server = view_server
+        self.platform_url = platform_url
+        self.user_id = user_id
+        self.user_pwd = user_pwd
+        self.url_marker = "data-engineer"
+
+    @dynamic_catch
+    async def _async_find_tabular_data_sets(
+        self,
+        search_string: str = "*",
+        body: dict | SearchStringRequestBody = None,
+    ) -> list | str:
+        url = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/data-engineer/assets/by-search-string"
+        if body is None:
+            body = {
+                "class": "SearchStringRequestBody",
+                "searchString": search_string,
+                "metadataElementTypeName": "TabularDataSet",
+                "skipClassifiedElements": ["Template"],
+            }
+        response = await self._async_make_request("POST", url, body)
+        return response.json().get("elements")
+
+    def find_tabular_data_sets(
+        self,
+        search_string: str = "*",
+        body: dict | SearchStringRequestBody = None,
+    ) -> list | str:
+        loop = asyncio.get_event_loop()
+        return loop.run_until_complete(self._async_find_tabular_data_sets(search_string, body))
+
+    @dynamic_catch
+    async def _async_get_tabular_data_set_report(
+        self,
+        guid: str,
+        start_from_row: int = 0,
+        max_row_count: int = 5000,
+    ) -> dict | str:
+        url = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/data-engineer/tabular-data-sets/{guid}/report?startFromRow={start_from_row}&maxRowCount={max_row_count}"
+        response = await self._async_make_request("GET", url)
+        return response.json()
+
+    def get_tabular_data_set_report(
+        self,
+        guid: str,
+        start_from_row: int = 0,
+        max_row_count: int = 5000,
+    ) -> dict | str:
+        loop = asyncio.get_event_loop()
+        return loop.run_until_complete(
+            self._async_get_tabular_data_set_report(guid, start_from_row, max_row_count)
+        )
+
+    @dynamic_catch
+    async def _async_find_assets_by_name(
+        self,
+        filter_string: str,
+        metadata_element_type_name: str = "ReferenceCodeTable",
+        start_from: int = 0,
+        page_size: int = 10,
+    ) -> list | str:
+        url = f"{self.platform_url}/servers/{self.view_server}/api/open-metadata/asset-maker/assets/by-name"
+        body = {
+            "class": "FilterRequestBody",
+            "metadataElementTypeName": metadata_element_type_name,
+            "filter": filter_string,
+            "startFrom": start_from,
+            "pageSize": page_size,
+        }
+        response = await self._async_make_request("POST", url, body)
+        return response.json().get("elements")
+
+    def find_assets_by_name(
+        self,
+        filter_string: str,
+        metadata_element_type_name: str = "ReferenceCodeTable",
+        start_from: int = 0,
+        page_size: int = 10,
+    ) -> list | str:
+        loop = asyncio.get_event_loop()
+        return loop.run_until_complete(
+            self._async_find_assets_by_name(
+                filter_string, metadata_element_type_name, start_from, page_size
+            )
+        )

examples/output_formats_example.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+Example script demonstrating how to use the Pydantic models for output report specs.
+
+This script shows how to:
+1. Create custom columns, formats, and report specs
+2. Compose formats by reusing columns
+3. Add a custom report spec to the report_specs dictionary
+4. Use the functions in _output_formats.py with the new models
+"""
+
+import sys
+import os
+
+# Add the parent directory to the path so we can import the modules
+sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from pyegeria.view._output_format_models import Column, Format, ActionParameter, FormatSet
+from pyegeria.view.base_report_formats import (
+    report_specs,
+    select_report_spec,
+    report_spec_list,
+    get_report_spec_heading,
+    get_report_spec_description,
+    get_report_spec_match,
+)
+
+def create_custom_report_spec():
+    """
+    Create a custom format set with multiple formats.
+    
+    This demonstrates how to create columns, formats, and format sets,
+    and how to compose formats by reusing columns.
+    """
+    print("\n=== Creating a custom report spec ===")
+    
+    # Create common columns that will be used in multiple formats
+    common_columns = [
+        Column(name="ID", key="id"),
+        Column(name="Name", key="name"),
+        Column(name="Description", key="description", format=True),
+    ]
+    
+    # Create additional columns for specific formats
+    detail_columns = [
+        Column(name="Created By", key="created_by"),
+        Column(name="Created Date", key="created_date"),
+        Column(name="Modified By", key="modified_by"),
+        Column(name="Modified Date", key="modified_date"),
+    ]
+    
+    technical_columns = [
+        Column(name="Type", key="type"),
+        Column(name="Status", key="status"),
+        Column(name="Version", key="version"),
+    ]
+    
+    # Create formats that reuse and compose columns
+    table_format = Format(
+        types=["TABLE"],
+        columns=common_columns,  # Basic columns for table view
+    )
+    
+    detail_format = Format(
+        types=["DETAIL", "FORM"],
+        columns=common_columns + detail_columns,  # Common columns plus detail columns
+    )
+    
+    technical_format = Format(
+        types=["TECHNICAL", "DICT"],
+        columns=common_columns + technical_columns,  # Common columns plus technical columns
+    )
+    
+    full_format = Format(
+        types=["FULL", "REPORT"],
+        columns=common_columns + detail_columns + technical_columns,  # All columns
+    )
+    
+    # Create a report spec (format set) that includes all the formats
+    custom_format_set = FormatSet(
+        heading="Custom Example Format Set",
+        description="A custom format set demonstrating composition of formats",
+        aliases=["CustomExample", "Example"],
+        annotations={"wikilinks": ["[[Example]]", "[[Custom]]"]},
+        formats=[table_format, detail_format, technical_format, full_format],
+        action=[
+            ActionParameter(
+                function="ExampleManager.find_examples",
+                required_params=["search_string"],
+                spec_params={},
+            )
+        ],
+    )
+    
+    # Print information about the report spec
+    print(f"Created report spec: {custom_format_set.heading}")
+    print(f"Description: {custom_format_set.description}")
+    print(f"Aliases: {custom_format_set.aliases}")
+    print(f"Number of formats: {len(custom_format_set.formats)}")
+    
+    # Print information about each format
+    for i, format in enumerate(custom_format_set.formats):
+        print(f"\nFormat {i+1}:")
+        print(f"  Types: {format.types}")
+        print(f"  Number of columns: {len(format.columns)}")
+        print(f"  Columns: {[column.name for column in format.columns]}")
+    
+    return custom_format_set
+
+def add_report_spec_to_dictionary(format_set):
+    """
+    Add a report spec to the report_specs dictionary.
+    
+    This demonstrates how to add a custom report spec to the
+    report_specs dictionary for use with the functions
+    in _output_formats.py.
+    """
+    print("\n=== Adding report spec to dictionary ===")
+    
+    # Add the report spec to the report_specs dictionary
+    report_specs["CustomExample"] = format_set
+    
+    # Verify that the report spec was added
+    format_sets = report_spec_list()
+    if "CustomExample" in format_sets:
+        print("Report spec successfully added to the dictionary!")
+        print(f"Available report specs: {format_sets}")
+    else:
+        print("Failed to add report spec to the dictionary.")
+
+def use_output_format_functions():
+    """
+    Use the functions in _output_formats.py with the new models.
+    
+    This demonstrates how to use the functions in _output_formats.py
+    with the new Pydantic models.
+    """
+    print("\n=== Using output format functions ===")
+    
+    # Get a report spec by name
+    format_set = select_report_spec("CustomExample", "TABLE")
+    if format_set:
+        print("Successfully retrieved report spec by name!")
+        print(f"Heading: {format_set['heading']}")
+        print(f"Description: {format_set['description']}")
+    else:
+        print("Failed to retrieve report spec by name.")
+    
+    # Get a report spec by alias
+    format_set = select_report_spec("Example", "TABLE")
+    if format_set:
+        print("\nSuccessfully retrieved report spec by alias!")
+        print(f"Heading: {format_set['heading']}")
+        print(f"Description: {format_set['description']}")
+    else:
+        print("\nFailed to retrieve report spec by alias.")
+    
+    # Get the heading and description of a report spec
+    heading = get_report_spec_heading("CustomExample")
+    description = get_report_spec_description("CustomExample")
+    print(f"\nHeading: {heading}")
+    print(f"Description: {description}")
+    
+    # Match a report spec with a specific output type
+    format_set = select_report_spec("CustomExample", "ANY")
+    matched_format_set = get_report_spec_match(format_set, "DETAIL")
+    if matched_format_set and "formats" in matched_format_set:
+        print("\nSuccessfully matched report spec with output type!")
+        print(f"Output type: {matched_format_set['formats']['types']}")
+        print(f"Number of columns: {len(matched_format_set['formats']['columns'])}")
+    else:
+        print("\nFailed to match report spec with output type.")
+
+def main():
+    """Run the example script."""
+    print("=== Output Formats Example ===")
+    
+    # Create a custom report spec
+    custom_format_set = create_custom_report_spec()
+    
+    # Add the report spec to the report_specs dictionary
+    add_report_spec_to_dictionary(custom_format_set)
+    
+    # Use the functions in _output_formats.py with the new models
+    use_output_format_functions()
+    
+    print("\n=== Example Complete ===")
+
+if __name__ == "__main__":
+    main()

examples/test_jacquard_data_sets.py

@@ -0,0 +1,54 @@
+"""
+PDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+This module tests the JacquardDataSets class and methods from jacquard_data_sets.py
+"""
+
+from rich import print
+from rich.console import Console
+
+from pyegeria.core._exceptions import (
+    PyegeriaInvalidParameterException,
+    PyegeriaConnectionException,
+    PyegeriaAPIException,
+    PyegeriaNotFoundException,
+)
+from examples.jacquard_data_sets import JacquardDataSets
+from pyegeria.core.logging_configuration import config_logging, init_logging
+
+disable_ssl_warnings = True
+
+console = Console(width=250)
+
+config_logging()
+init_logging(True)
+
+VIEW_SERVER = "qs-view-server"
+PLATFORM_URL = "https://localhost:9443"
+USER_ID = "peterprofile"
+USER_PWD = "secret"
+
+
+class TestJacquardDataSets:
+    good_platform1_url = PLATFORM_URL
+    good_user_1 = USER_ID
+    good_user_2 = USER_ID
+    good_view_server_1 = VIEW_SERVER
+
+    def test_find_tabular_data_sets(self):
+        """Test finding tabular data sets"""
+        jds_client = JacquardDataSets(self.good_view_server_1, self.good_platform1_url, user_id=self.good_user_2)
+        try:
+            jds_client.create_egeria_bearer_token(self.good_user_2, USER_PWD)
+            
+            try:
+                response = jds_client.find_tabular_data_sets(search_string="*")
+                assert response is not None
+            except (PyegeriaInvalidParameterException, PyegeriaNotFoundException, PyegeriaAPIException):
+                pass
+
+        except PyegeriaConnectionException:
+            print("Skipping test due to connection error")
+        finally:
+            jds_client.close_session()