trustgraph-cli 2.2.2__tar.gz → 2.2.4__tar.gz

{trustgraph_cli-2.2.2 → trustgraph_cli-2.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustgraph-cli
-Version: 2.2.2
+Version: 2.2.4
 Summary: TrustGraph provides a means to run a pipeline of flexible AI processing components in a flexible means to achieve a processing pipeline.
 Author-email: "trustgraph.ai" <security@trustgraph.ai>
 Project-URL: Homepage, https://github.com/trustgraph-ai/trustgraph

{trustgraph_cli-2.2.2 → trustgraph_cli-2.2.4}/trustgraph/cli/list_explain_traces.py

@@ -58,6 +58,14 @@ def print_json(sessions):
     print(json.dumps(sessions, indent=2))
 
 
+# Map type names for display
+TYPE_DISPLAY = {
+    "graphrag": "GraphRAG",
+    "docrag": "DocRAG",
+    "agent": "Agent",
+}
+
+
 def main():
     parser = argparse.ArgumentParser(
         prog='tg-list-explain-traces',
@@ -118,7 +126,7 @@ def main():
         explain_client = ExplainabilityClient(flow)
 
         try:
-            # List all sessions using the API
+            # List all sessions — uses persistent websocket via SocketClient
             questions = explain_client.list_sessions(
                 graph=RETRIEVAL_GRAPH,
                 user=args.user,
@@ -126,7 +134,8 @@ def main():
                 limit=args.limit,
             )
 
-            # Convert to output format
+            # detect_session_type is mostly a fast URI pattern check,
+            # only falls back to network calls for unrecognised URIs
             sessions = []
             for q in questions:
                 session_type = explain_client.detect_session_type(
@@ -136,16 +145,9 @@ def main():
                     collection=args.collection
                 )
 
-                # Map type names
-                type_display = {
-                    "graphrag": "GraphRAG",
-                    "docrag": "DocRAG",
-                    "agent": "Agent",
-                }.get(session_type, session_type.title())
-
                 sessions.append({
                     "id": q.uri,
-                    "type": type_display,
+                    "type": TYPE_DISPLAY.get(session_type, session_type.title()),
                     "question": q.query,
                     "time": q.timestamp,
                 })

trustgraph_cli-2.2.4/trustgraph/cli/show_flow_blueprints.py

@@ -0,0 +1,173 @@
+"""
+Shows all defined flow blueprints.
+"""
+
+import argparse
+import asyncio
+import os
+import tabulate
+from trustgraph.api import AsyncSocketClient
+import json
+
+default_url = os.getenv("TRUSTGRAPH_URL", 'http://localhost:8088/')
+default_token = os.getenv("TRUSTGRAPH_TOKEN", None)
+
+def format_parameters(params_metadata, param_type_defs):
+    """
+    Format parameter metadata for display.
+
+    param_type_defs is a dict of type_name -> parsed type definition,
+    pre-fetched concurrently.
+    """
+    if not params_metadata:
+        return "None"
+
+    param_list = []
+
+    sorted_params = sorted(
+        params_metadata.items(),
+        key=lambda x: x[1].get("order", 999)
+    )
+
+    for param_name, param_meta in sorted_params:
+        description = param_meta.get("description", param_name)
+        param_type = param_meta.get("type", "unknown")
+
+        type_info = param_type
+        if param_type in param_type_defs:
+            param_type_def = param_type_defs[param_type]
+            default = param_type_def.get("default")
+            if default is not None:
+                type_info = f"{param_type} (default: {default})"
+
+        param_list.append(f"  {param_name}: {description} [{type_info}]")
+
+    return "\n".join(param_list)
+
+async def fetch_data(client):
+    """Fetch all data needed for show_flow_blueprints concurrently."""
+
+    # Round 1: list blueprints
+    resp = await client._send_request("flow", None, {
+        "operation": "list-blueprints",
+    })
+    blueprint_names = resp.get("blueprint-names", [])
+
+    if not blueprint_names:
+        return [], {}, {}
+
+    # Round 2: get all blueprints in parallel
+    blueprint_tasks = [
+        client._send_request("flow", None, {
+            "operation": "get-blueprint",
+            "blueprint-name": name,
+        })
+        for name in blueprint_names
+    ]
+    blueprint_results = await asyncio.gather(*blueprint_tasks)
+
+    blueprints = {}
+    for name, resp in zip(blueprint_names, blueprint_results):
+        bp_data = resp.get("blueprint-definition", "{}")
+        blueprints[name] = json.loads(bp_data) if isinstance(bp_data, str) else bp_data
+
+    # Round 3: get all parameter type definitions in parallel
+    param_types_needed = set()
+    for bp in blueprints.values():
+        for param_meta in bp.get("parameters", {}).values():
+            pt = param_meta.get("type", "")
+            if pt:
+                param_types_needed.add(pt)
+
+    param_type_defs = {}
+    if param_types_needed:
+        param_type_tasks = [
+            client._send_request("config", None, {
+                "operation": "get",
+                "keys": [{"type": "parameter-type", "key": pt}],
+            })
+            for pt in param_types_needed
+        ]
+        param_type_results = await asyncio.gather(*param_type_tasks)
+
+        for pt, resp in zip(param_types_needed, param_type_results):
+            values = resp.get("values", [])
+            if values:
+                try:
+                    param_type_defs[pt] = json.loads(values[0].get("value", "{}"))
+                except (json.JSONDecodeError, AttributeError):
+                    pass
+
+    return blueprint_names, blueprints, param_type_defs
+
+async def _show_flow_blueprints_async(url, token=None):
+    async with AsyncSocketClient(url, timeout=60, token=token) as client:
+        return await fetch_data(client)
+
+def show_flow_blueprints(url, token=None):
+
+    blueprint_names, blueprints, param_type_defs = asyncio.run(
+        _show_flow_blueprints_async(url, token=token)
+    )
+
+    if not blueprint_names:
+        print("No flow blueprints.")
+        return
+
+    for blueprint_name in blueprint_names:
+        cls = blueprints[blueprint_name]
+
+        table = []
+        table.append(("name", blueprint_name))
+        table.append(("description", cls.get("description", "")))
+
+        tags = cls.get("tags", [])
+        if tags:
+            table.append(("tags", ", ".join(tags)))
+
+        parameters = cls.get("parameters", {})
+        if parameters:
+            param_str = format_parameters(parameters, param_type_defs)
+            table.append(("parameters", param_str))
+
+        print(tabulate.tabulate(
+            table,
+            tablefmt="pretty",
+            stralign="left",
+        ))
+        print()
+
+def main():
+
+    parser = argparse.ArgumentParser(
+        prog='tg-show-flow-blueprints',
+        description=__doc__,
+    )
+
+    parser.add_argument(
+        '-u', '--api-url',
+        default=default_url,
+        help=f'API URL (default: {default_url})',
+    )
+
+    parser.add_argument(
+        '-t', '--token',
+        default=default_token,
+        help='Authentication token (default: $TRUSTGRAPH_TOKEN)',
+    )
+
+    args = parser.parse_args()
+
+    try:
+
+        show_flow_blueprints(
+            url=args.api_url,
+            token=args.token,
+        )
+
+    except Exception as e:
+
+        print("Exception:", e, flush=True)
+
+if __name__ == "__main__":
+    main()

trustgraph_cli-2.2.4/trustgraph/cli/show_flows.py

@@ -0,0 +1,286 @@
+"""
+Shows configured flows.
+"""
+
+import argparse
+import asyncio
+import os
+import tabulate
+from trustgraph.api import Api, AsyncSocketClient
+import json
+
+default_url = os.getenv("TRUSTGRAPH_URL", 'http://localhost:8088/')
+default_token = os.getenv("TRUSTGRAPH_TOKEN", None)
+
+def describe_interfaces(intdefs, flow):
+
+    intfs = flow.get("interfaces", {})
+
+    lst = []
+
+    for k, v in intdefs.items():
+
+        if intdefs[k].get("visible", False):
+
+            label = intdefs[k].get("description", k)
+            kind = intdefs[k].get("kind", None)
+
+            if kind == "request-response":
+                req = intfs[k]["request"]
+                resp = intfs[k]["response"]
+
+                lst.append(f"{k} request: {req}")
+                lst.append(f"{k} response: {resp}")
+
+            if kind == "send":
+                q = intfs[k]
+
+                lst.append(f"{k}: {q}")
+
+    return "\n".join(lst)
+
+def get_enum_description(param_value, param_type_def):
+    """
+    Get the human-readable description for an enum value
+    """
+    enum_list = param_type_def.get("enum", [])
+
+    for enum_item in enum_list:
+        if isinstance(enum_item, dict):
+            if enum_item.get("id") == param_value:
+                return enum_item.get("description", param_value)
+        elif enum_item == param_value:
+            return param_value
+
+    return param_value
+
+def format_parameters(flow_params, blueprint_params_metadata, param_type_defs):
+    """
+    Format flow parameters with their human-readable descriptions.
+
+    param_type_defs is a dict of type_name -> parsed type definition,
+    pre-fetched concurrently.
+    """
+    if not flow_params:
+        return "None"
+
+    param_list = []
+
+    sorted_params = sorted(
+        blueprint_params_metadata.items(),
+        key=lambda x: x[1].get("order", 999)
+    )
+
+    for param_name, param_meta in sorted_params:
+        if param_name in flow_params:
+            value = flow_params[param_name]
+            description = param_meta.get("description", param_name)
+            param_type = param_meta.get("type", "")
+            controlled_by = param_meta.get("controlled-by", None)
+
+            display_value = value
+            if param_type and param_type in param_type_defs:
+                display_value = get_enum_description(
+                    value, param_type_defs[param_type]
+                )
+
+            line = f"• {description}: {display_value}"
+
+            if controlled_by:
+                line += f" (controlled by {controlled_by})"
+
+            param_list.append(line)
+
+    for param_name, value in flow_params.items():
+        if param_name not in blueprint_params_metadata:
+            param_list.append(f"• {param_name}: {value} (undefined)")
+
+    return "\n".join(param_list) if param_list else "None"
+
+async def fetch_show_flows(client):
+    """Fetch all data needed for show_flows concurrently."""
+
+    # Round 1: list interfaces and list flows in parallel
+    interface_names_resp, flow_ids_resp = await asyncio.gather(
+        client._send_request("config", None, {
+            "operation": "list",
+            "type": "interface-description",
+        }),
+        client._send_request("flow", None, {
+            "operation": "list-flows",
+        }),
+    )
+
+    interface_names = interface_names_resp.get("directory", [])
+    flow_ids = flow_ids_resp.get("flow-ids", [])
+
+    if not flow_ids:
+        return {}, [], {}, {}
+
+    # Round 2: get all interfaces + all flows in parallel
+    interface_tasks = [
+        client._send_request("config", None, {
+            "operation": "get",
+            "keys": [{"type": "interface-description", "key": name}],
+        })
+        for name in interface_names
+    ]
+
+    flow_tasks = [
+        client._send_request("flow", None, {
+            "operation": "get-flow",
+            "flow-id": fid,
+        })
+        for fid in flow_ids
+    ]
+
+    results = await asyncio.gather(*interface_tasks, *flow_tasks)
+
+    # Split results
+    interface_results = results[:len(interface_names)]
+    flow_results = results[len(interface_names):]
+
+    # Parse interfaces
+    interface_defs = {}
+    for name, resp in zip(interface_names, interface_results):
+        values = resp.get("values", [])
+        if values:
+            interface_defs[name] = json.loads(values[0].get("value", "{}"))
+
+    # Parse flows
+    flows = {}
+    for fid, resp in zip(flow_ids, flow_results):
+        flow_data = resp.get("flow", "{}")
+        flows[fid] = json.loads(flow_data) if isinstance(flow_data, str) else flow_data
+
+    # Round 3: get all blueprints in parallel
+    blueprint_names = set()
+    for flow in flows.values():
+        bp = flow.get("blueprint-name", "")
+        if bp:
+            blueprint_names.add(bp)
+
+    blueprint_tasks = [
+        client._send_request("flow", None, {
+            "operation": "get-blueprint",
+            "blueprint-name": bp_name,
+        })
+        for bp_name in blueprint_names
+    ]
+
+    blueprint_results = await asyncio.gather(*blueprint_tasks)
+
+    blueprints = {}
+    for bp_name, resp in zip(blueprint_names, blueprint_results):
+        bp_data = resp.get("blueprint-definition", "{}")
+        blueprints[bp_name] = json.loads(bp_data) if isinstance(bp_data, str) else bp_data
+
+    # Round 4: get all parameter type definitions in parallel
+    param_types_needed = set()
+    for bp in blueprints.values():
+        for param_meta in bp.get("parameters", {}).values():
+            pt = param_meta.get("type", "")
+            if pt:
+                param_types_needed.add(pt)
+
+    param_type_tasks = [
+        client._send_request("config", None, {
+            "operation": "get",
+            "keys": [{"type": "parameter-type", "key": pt}],
+        })
+        for pt in param_types_needed
+    ]
+
+    param_type_results = await asyncio.gather(*param_type_tasks)
+
+    param_type_defs = {}
+    for pt, resp in zip(param_types_needed, param_type_results):
+        values = resp.get("values", [])
+        if values:
+            try:
+                param_type_defs[pt] = json.loads(values[0].get("value", "{}"))
+            except (json.JSONDecodeError, AttributeError):
+                pass
+
+    return interface_defs, flow_ids, flows, blueprints, param_type_defs
+
+async def _show_flows_async(url, token=None):
+
+    async with AsyncSocketClient(url, timeout=60, token=token) as client:
+        return await fetch_show_flows(client)
+
+def show_flows(url, token=None):
+
+    result = asyncio.run(_show_flows_async(url, token=token))
+
+    interface_defs, flow_ids, flows, blueprints, param_type_defs = result
+
+    if not flow_ids:
+        print("No flows.")
+        return
+
+    for fid in flow_ids:
+
+        flow = flows[fid]
+
+        table = []
+        table.append(("id", fid))
+        table.append(("blueprint", flow.get("blueprint-name", "")))
+        table.append(("desc", flow.get("description", "")))
+
+        parameters = flow.get("parameters", {})
+        if parameters:
+            blueprint_name = flow.get("blueprint-name", "")
+            if blueprint_name and blueprint_name in blueprints:
+                blueprint_params_metadata = blueprints[blueprint_name].get("parameters", {})
+                param_str = format_parameters(
+                    parameters, blueprint_params_metadata, param_type_defs
+                )
+            else:
+                param_str = json.dumps(parameters, indent=2)
+
+            table.append(("parameters", param_str))
+
+        table.append(("queue", describe_interfaces(interface_defs, flow)))
+
+        print(tabulate.tabulate(
+            table,
+            tablefmt="pretty",
+            stralign="left",
+        ))
+        print()
+
+def main():
+
+    parser = argparse.ArgumentParser(
+        prog='tg-show-flows',
+        description=__doc__,
+    )
+
+    parser.add_argument(
+        '-u', '--api-url',
+        default=default_url,
+        help=f'API URL (default: {default_url})',
+    )
+
+    parser.add_argument(
+        '-t', '--token',
+        default=default_token,
+        help='Authentication token (default: $TRUSTGRAPH_TOKEN)',
+    )
+
+    args = parser.parse_args()
+
+    try:
+
+        show_flows(
+            url=args.api_url,
+            token=args.token,
+        )
+
+    except Exception as e:
+
+        print("Exception:", e, flush=True)
+
+if __name__ == "__main__":
+    main()