pyegeria 5.3.3.9__py3-none-any.whl → 5.3.3.10__py3-none-any.whl

pyegeria/commands/tech/list_information_supply_chains.py

@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""
+SPDX-License-Identifier: Apache-2.0
+Copyright Contributors to the ODPi Egeria project.
+
+A simple viewer for Information Supply Chains
+
+"""
+
+import argparse
+import os
+import time
+
+from rich import print, box
+from rich.console import Console
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.prompt import Prompt
+from rich.table import Table
+from rich.text import Text
+from rich.tree import Tree
+from pyegeria.solution_architect_omvs import SolutionArchitect
+from pyegeria import (
+    ProjectManager,
+    UserNotAuthorizedException,
+    PropertyServerException,
+    InvalidParameterException,
+    )
+
+from pyegeria._exceptions import (
+    print_exception_response,
+)
+
+disable_ssl_warnings = True
+EGERIA_METADATA_STORE = os.environ.get("EGERIA_METADATA_STORE", "active-metadata-store")
+EGERIA_KAFKA_ENDPOINT = os.environ.get("KAFKA_ENDPOINT", "localhost:9092")
+EGERIA_PLATFORM_URL = os.environ.get("EGERIA_PLATFORM_URL", "https://localhost:9443")
+EGERIA_VIEW_SERVER = os.environ.get("EGERIA_VIEW_SERVER", "qs-view-server")
+EGERIA_VIEW_SERVER_URL = os.environ.get(
+    "EGERIA_VIEW_SERVER_URL", "https://localhost:9443"
+)
+EGERIA_INTEGRATION_DAEMON = os.environ.get("INTEGRATION_DAEMON", "integration-daemon")
+EGERIA_ADMIN_USER = os.environ.get("ADMIN_USER", "garygeeke")
+EGERIA_ADMIN_PASSWORD = os.environ.get("ADMIN_PASSWORD", "secret")
+EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
+EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
+EGERIA_JUPYTER = bool(os.environ.get("EGERIA_JUPYTER", "False"))
+EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "150"))
+
+
+def supply_chain_viewer(
+    search_string: str,
+    server_name: str,
+    platform_url: str,
+    user: str,
+    user_password: str,
+    jupyter: bool = EGERIA_JUPYTER,
+    width: int = EGERIA_WIDTH,
+    timeout: int = 30,
+):
+    """A Supply Chain viewer"""
+    client = SolutionArchitect(server_name, platform_url, user, user_password)
+    token = client.create_egeria_bearer_token()
+
+    def generate_table() -> Table | str:
+        table = Table(
+            title=f"Supply Chains matching  {search_string} @ {time.asctime()}",
+            style="bright_white on black",
+            header_style="bright_white on dark_blue",
+            title_style="bold white on black",
+            caption_style="white on black",
+            show_lines=True,
+            box=box.ROUNDED,
+            caption=f"View Server '{server_name}' @ Platform - {platform_url}",
+            expand=True,
+            )
+        table.add_column("Supply Chain Name")
+        table.add_column("Qualified Name \n/\n GUID", width=38, no_wrap=False)
+        table.add_column("Purpose")
+        table.add_column("Scope\n/\n Mermaid Link")
+        table.add_column("Description")
+
+        supply_chains = client.find_information_supply_chains(search_string)
+        if isinstance(supply_chains, list) is False:
+            return "No Supply Chains found"
+
+        for sc in supply_chains:
+            sc_name = sc["properties"].get("displayName", '---')
+            sc_qname = sc["properties"].get("qualifiedName", '---')
+            sc_guid = sc["elementHeader"]["guid"]
+            sc_purpose = sc["properties"].get("purposes",'---')
+            if isinstance(sc_purpose, list):
+                sc_purpose_str = "\n* ".join(sc_purpose)
+            else:
+                sc_purpose_str = sc_purpose
+            sc_scope = sc["properties"].get("scope",'---')
+            sc_desc = sc["properties"].get("description",'---')
+            sc_unique_name = f"{sc_qname}\n\n\t\t/\n\n{sc_guid}"
+            sc_mermaid = sc.get("mermaid",'---')
+
+            table.add_row(sc_name, sc_unique_name, sc_purpose_str, sc_scope, sc_desc)
+
+        return table
+
+
+
+
+    try:
+        console = Console(width=width, force_terminal=not jupyter)
+        with console.pager():
+            console.print(generate_table())
+
+    except (
+        InvalidParameterException,
+        PropertyServerException,
+        UserNotAuthorizedException,
+    ) as e:
+        print_exception_response(e)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+
+    parser.add_argument("--server", help="Name of the server to display status for")
+    parser.add_argument("--url", help="URL Platform to connect to")
+    parser.add_argument("--userid", help="User Id")
+    parser.add_argument("--password", help="User Password")
+    args = parser.parse_args()
+
+    server = args.server if args.server is not None else EGERIA_VIEW_SERVER
+    url = args.url if args.url is not None else EGERIA_PLATFORM_URL
+    userid = args.userid if args.userid is not None else EGERIA_USER
+    user_pass = args.password if args.password is not None else EGERIA_USER_PASSWORD
+
+    try:
+        search_string = Prompt.ask(
+            "Enter a search string:", default="*"
+        )
+        supply_chain_viewer(search_string, server, url, userid, user_pass)
+    except KeyboardInterrupt:
+        pass
+
+
+if __name__ == "__main__":
+    main()

pyegeria/egeria_client.py

@@ -29,6 +29,7 @@ from pyegeria import (
     FullServerConfig,
     EgeriaConfig,
     MetadataExplorer,
+    SolutionArchitect
 )
 
 
@@ -50,6 +51,7 @@ class Egeria(
     # TemplateManager,
     ValidMetadataManager,
     MetadataExplorer,
+    SolutionArchitect,
 ):
     """
     Client to issue Runtime status requests.
@@ -115,3 +117,6 @@ class Egeria(
         ValidMetadataManager.__init__(
             self, view_server, platform_url, user_id, user_pwd, token
         )
+        SolutionArchitect.__init__(
+            self, view_server, platform_url, user_id, user_pwd, token
+            )

pyegeria/egeria_tech_client.py

@@ -24,7 +24,8 @@ from pyegeria import (
     TEMPLATE_GUIDS,
     INTEGRATION_GUIDS,
     MetadataExplorer,
-)
+    SolutionArchitect,
+    )
 
 
 class EgeriaTech(
@@ -36,6 +37,7 @@ class EgeriaTech(
     RuntimeManager,
     ValidMetadataManager,
     MetadataExplorer,
+    SolutionArchitect,
 ):
     """
     Client for technical Egeria users.
@@ -87,7 +89,9 @@ class EgeriaTech(
         MetadataExplorer.__init__(
             self, view_server, platform_url, user_id, user_pwd, token
         )
-
+        SolutionArchitect.__init__(
+            self, view_server, platform_url, user_id, user_pwd, token
+            )
 
 if __name__ == "__main__":
     print("Main-Tech Client")

pyegeria/mermaid_utilities.py

@@ -40,26 +40,26 @@ EGERIA_USER = os.environ.get("EGERIA_USER", "erinoverview")
 EGERIA_USER_PASSWORD = os.environ.get("EGERIA_USER_PASSWORD", "secret")
 EGERIA_JUPYTER = bool(os.environ.get("EGERIA_JUPYTER", "False"))
 EGERIA_WIDTH = int(os.environ.get("EGERIA_WIDTH", "200"))
-
+EGERIA_MERMAID_FOLDER = os.environ.get("EGERIA_MERMAID_FOLDER", "./work/mermaid_graphs")
 
 # Check Mermaid.js version
-def check_mermaid_version():
-    """Check the version of Mermaid.js loaded in Jupyter Notebook"""
-    display(HTML("""
-    <script>
-        function checkMermaid() {
-            if (window.mermaid && typeof window.mermaid.version !== "undefined") {
-                console.log("Mermaid.js version:", mermaid.version);
-                alert("Mermaid.js version: " + mermaid.version);
-            } else {
-                console.warn("Mermaid.js is not loaded yet. Please ensure it's properly injected.");
-                alert("Mermaid.js is not loaded yet. Please ensure it's properly injected.");
-            }
-        }
-        // Delay execution to ensure Mermaid.js has had time to load
-        setTimeout(checkMermaid, 1000);
-    </script>
-    """))
+# def check_mermaid_version():
+#     """Check the version of Mermaid.js loaded in Jupyter Notebook"""
+#     display(HTML("""
+#     <script>
+#         function checkMermaid() {
+#             if (window.mermaid && typeof window.mermaid.version !== "undefined") {
+#                 console.log("Mermaid.js version:", mermaid.version);
+#                 alert("Mermaid.js version: " + mermaid.version);
+#             } else {
+#                 console.warn("Mermaid.js is not loaded yet. Please ensure it's properly injected.");
+#                 alert("Mermaid.js is not loaded yet. Please ensure it's properly injected.");
+#             }
+#         }
+#         // Delay execution to ensure Mermaid.js has had time to load
+#         setTimeout(checkMermaid, 1000);
+#     </script>
+#     """))
 
 # another site to get mermaid from is "https://cdnjs.cloudflare.com/ajax/libs/mermaid/11.4.1/mermaid.min.js";
 # below was:
@@ -77,9 +77,9 @@ def load_mermaid():
     mermaid_js = """
     <script src="https://unpkg.com/mermaid@11.4.1/dist/mermaid.min.js"></script>
     <script>
-        document.addEventListener('DOMContentLoaded', function() {{
-            mermaid.initialize({{"startOnLoad": true}});
-        }});
+        document.addEventListener('DOMContentLoaded', function() {
+            mermaid.initialize({startOnLoad: true});
+        });
     </script>
 
     """
@@ -110,6 +110,36 @@ def render_mermaid(mermaid_code):
     """
     display(HTML(mermaid_html))
 
+def save_mermaid_graph(title, mermaid_code, folder:str = EGERIA_MERMAID_FOLDER):
+    """Save a Mermaid diagram to a file"""
+    if not os.path.exists(folder):
+        os.makedirs(folder)
+    mermaid_file = os.path.join(folder, title + ".mmd")
+    mermaid_code = f"""
+<!DOCTYPE html>
+<html>
+<head>
+  <script src="https://cdn.jsdelivr.net/npm/mermaid/dist/mermaid.min.js"></script>
+</head>
+<body>
+  <div class="mermaid">
+    {mermaid_code}
+  </div>
+""" \
++ \
+"""
+  <script>
+    mermaid.initialize({startOnLoad:true});
+  </script>
+</body>
+</html>
+"""
+
+    with open(mermaid_file, "w") as f:
+        f.write(mermaid_code)
+    return mermaid_file
+
+
 
 def generate_process_graph(
     process_guid: str,

pyegeria/metadata_explorer_omvs.py

@@ -489,49 +489,6 @@ class MetadataExplorer(Client):
         )
         return response
 
-    # def get_metadata_element_mermaid_graph(
-    #     self,
-    #     guid: str,
-    #     effective_time: str = None,
-    #     as_of_time: str = None,
-    #     for_lineage: bool = None,
-    #     for_duplicate_processing: bool = None,
-    # ) -> dict | str:
-    #     """
-    #     Retrieve the metadata element using its unique identifier.
-    #
-    #     Parameters
-    #     ----------
-    #     guid : str
-    #         - unique identifier of the element to retrieve
-    #     effective_time: str, default = None
-    #         - Time format is "YYYY-MM-DDTHH:MM:SS" (ISO 8601)
-    #     as_of_time: str, default = None
-    #         - Query the element as of this time. If None, then use current time.
-    #     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
-    #
-    #     Returns
-    #     -------
-    #     dict | str
-    #         If the element is found, a dict of the element details is returned. Otherwise the string "No element found".
-    #
-    #     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.
-    #     """
-    #
-    #     response = self.get_metadata_element_graph(
-    #         guid, effective_time, as_of_time, for_lineage, for_duplicate_processing
-    #     )
-    #     return response.get("mermaidGraph", NO_ELEMENTS_FOUND)
 
     async def _async_get_metadata_element_by_unique_name(
         self,