trustgraph-cli 1.4.12__tar.gz → 1.4.14__tar.gz

{trustgraph_cli-1.4.12 → trustgraph_cli-1.4.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustgraph-cli
-Version: 1.4.12
+Version: 1.4.14
 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-1.4.12 → trustgraph_cli-1.4.14}/pyproject.toml

@@ -72,6 +72,7 @@ tg-show-kg-cores = "trustgraph.cli.show_kg_cores:main"
 tg-show-library-documents = "trustgraph.cli.show_library_documents:main"
 tg-show-library-processing = "trustgraph.cli.show_library_processing:main"
 tg-show-mcp-tools = "trustgraph.cli.show_mcp_tools:main"
+tg-show-parameter-types = "trustgraph.cli.show_parameter_types:main"
 tg-show-processor-state = "trustgraph.cli.show_processor_state:main"
 tg-show-prompts = "trustgraph.cli.show_prompts:main"
 tg-show-token-costs = "trustgraph.cli.show_token_costs:main"

trustgraph_cli-1.4.14/trustgraph/cli/show_flow_classes.py

@@ -0,0 +1,122 @@
+"""
+Shows all defined flow classes.
+"""
+
+import argparse
+import os
+import tabulate
+from trustgraph.api import Api, ConfigKey
+import json
+
+default_url = os.getenv("TRUSTGRAPH_URL", 'http://localhost:8088/')
+
+def format_parameters(params_metadata, config_api):
+    """
+    Format parameter metadata for display
+
+    Args:
+        params_metadata: Parameter definitions from flow class
+        config_api: API client to get parameter type information
+
+    Returns:
+        Formatted string describing parameters
+    """
+    if not params_metadata:
+        return "None"
+
+    param_list = []
+
+    # Sort parameters by order if available
+    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")
+
+        # Get type information if available
+        type_info = param_type
+        if config_api:
+            try:
+                key = ConfigKey("parameter-types", param_type)
+                type_def_value = config_api.get([key])[0].value
+                param_type_def = json.loads(type_def_value)
+
+                # Add default value if available
+                default = param_type_def.get("default")
+                if default is not None:
+                    type_info = f"{param_type} (default: {default})"
+
+            except:
+                # If we can't get type definition, just show the type name
+                pass
+
+        param_list.append(f"  {param_name}: {description} [{type_info}]")
+
+    return "\n".join(param_list)
+
+def show_flow_classes(url):
+
+    api = Api(url)
+    flow_api = api.flow()
+    config_api = api.config()
+
+    class_names = flow_api.list_classes()
+
+    if len(class_names) == 0:
+        print("No flow classes.")
+        return
+
+    for class_name in class_names:
+        cls = flow_api.get_class(class_name)
+
+        table = []
+        table.append(("name", class_name))
+        table.append(("description", cls.get("description", "")))
+
+        tags = cls.get("tags", [])
+        if tags:
+            table.append(("tags", ", ".join(tags)))
+
+        # Show parameters if they exist
+        parameters = cls.get("parameters", {})
+        if parameters:
+            param_str = format_parameters(parameters, config_api)
+            table.append(("parameters", param_str))
+
+        print(tabulate.tabulate(
+            table,
+            tablefmt="pretty",
+            stralign="left",
+        ))
+        print()
+
+def main():
+
+    parser = argparse.ArgumentParser(
+        prog='tg-show-flow-classes',
+        description=__doc__,
+    )
+
+    parser.add_argument(
+        '-u', '--api-url',
+        default=default_url,
+        help=f'API URL (default: {default_url})',
+    )
+
+    args = parser.parse_args()
+
+    try:
+
+        show_flow_classes(
+            url=args.api_url,
+        )
+
+    except Exception as e:
+
+        print("Exception:", e, flush=True)
+
+if __name__ == "__main__":
+    main()

trustgraph_cli-1.4.14/trustgraph/cli/show_flows.py

@@ -0,0 +1,215 @@
+"""
+Shows configured flows.
+"""
+
+import argparse
+import os
+import tabulate
+from trustgraph.api import Api, ConfigKey
+import json
+
+default_url = os.getenv("TRUSTGRAPH_URL", 'http://localhost:8088/')
+
+def get_interface(config_api, i):
+
+    key = ConfigKey("interface-descriptions", i)
+
+    value = config_api.get([key])[0].value
+
+    return json.loads(value)
+
+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]["request"]
+
+                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
+
+    Args:
+        param_value: The actual parameter value (e.g., "gpt-4")
+        param_type_def: The parameter type definition containing enum objects
+
+    Returns:
+        Human-readable description or the original value if not found
+    """
+    enum_list = param_type_def.get("enum", [])
+
+    # Handle both old format (strings) and new format (objects with id/description)
+    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
+
+    # If not found in enum, return original value
+    return param_value
+
+def format_parameters(flow_params, class_params_metadata, config_api):
+    """
+    Format flow parameters with their human-readable descriptions
+
+    Args:
+        flow_params: The actual parameter values used in the flow
+        class_params_metadata: The parameter metadata from the flow class definition
+        config_api: API client to retrieve parameter type definitions
+
+    Returns:
+        Formatted string of parameters with descriptions
+    """
+    if not flow_params:
+        return "None"
+
+    param_list = []
+
+    # Sort parameters by order if available
+    sorted_params = sorted(
+        class_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)
+
+            # Try to get enum description if this parameter has a type definition
+            display_value = value
+            if param_type and config_api:
+                try:
+                    from trustgraph.api import ConfigKey
+                    key = ConfigKey("parameter-types", param_type)
+                    type_def_value = config_api.get([key])[0].value
+                    param_type_def = json.loads(type_def_value)
+                    display_value = get_enum_description(value, param_type_def)
+                except:
+                    # If we can't get the type definition, just use the original value
+                    display_value = value
+
+            # Format the parameter line
+            line = f"• {description}: {display_value}"
+
+            # Add controlled-by indicator if present
+            if controlled_by:
+                line += f" (controlled by {controlled_by})"
+
+            param_list.append(line)
+
+    # Add any parameters that aren't in the class metadata (shouldn't happen normally)
+    for param_name, value in flow_params.items():
+        if param_name not in class_params_metadata:
+            param_list.append(f"• {param_name}: {value} (undefined)")
+
+    return "\n".join(param_list) if param_list else "None"
+
+def show_flows(url):
+
+    api = Api(url)
+    config_api = api.config()
+    flow_api = api.flow()
+
+    interface_names = config_api.list("interface-descriptions")
+
+    interface_defs = {
+        i: get_interface(config_api, i)
+        for i in interface_names
+    }
+
+    flow_ids = flow_api.list()
+
+    if len(flow_ids) == 0:
+        print("No flows.")
+        return
+
+    flows = []
+
+    for id in flow_ids:
+
+        flow = flow_api.get(id)
+
+        table = []
+        table.append(("id", id))
+        table.append(("class", flow.get("class-name", "")))
+        table.append(("desc", flow.get("description", "")))
+
+        # Display parameters with human-readable descriptions
+        parameters = flow.get("parameters", {})
+        if parameters:
+            # Try to get the flow class definition for parameter metadata
+            class_name = flow.get("class-name", "")
+            if class_name:
+                try:
+                    flow_class = flow_api.get_class(class_name)
+                    class_params_metadata = flow_class.get("parameters", {})
+                    param_str = format_parameters(parameters, class_params_metadata, config_api)
+                except Exception as e:
+                    # Fallback to JSON if we can't get the class definition
+                    param_str = json.dumps(parameters, indent=2)
+            else:
+                # No class name, fallback to JSON
+                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})',
+    )
+
+    args = parser.parse_args()
+
+    try:
+
+        show_flows(
+            url=args.api_url,
+        )
+
+    except Exception as e:
+
+        print("Exception:", e, flush=True)
+
+if __name__ == "__main__":
+    main()

{trustgraph_cli-1.4.12 → trustgraph_cli-1.4.14}/trustgraph/cli/start_flow.py

@@ -1,5 +1,10 @@
 """
-Starts a processing flow using a defined flow class
+Starts a processing flow using a defined flow class.
+
+Parameters can be provided in three ways:
+1. As key=value pairs: --param model=gpt-4 --param temp=0.7
+2. As JSON string: -p '{"model": "gpt-4", "temp": 0.7}'
+3. As JSON file: --parameters-file params.json
 """
 
 import argparse
@@ -62,6 +67,12 @@ def main():
         help='Path to JSON file containing flow parameters',
     )
 
+    parser.add_argument(
+        '--param',
+        action='append',
+        help='Flow parameter as key=value pair (can be used multiple times, e.g., --param model=gpt-4 --param temp=0.7)',
+    )
+
     args = parser.parse_args()
 
     try:
@@ -73,6 +84,34 @@ def main():
                 parameters = json.load(f)
         elif args.parameters:
             parameters = json.loads(args.parameters)
+        elif args.param:
+            # Parse key=value pairs
+            parameters = {}
+            for param in args.param:
+                if '=' not in param:
+                    raise ValueError(f"Invalid parameter format: {param}. Expected key=value")
+
+                key, value = param.split('=', 1)
+                key = key.strip()
+                value = value.strip()
+
+                # Try to parse value as JSON first (for numbers, booleans, etc.)
+                try:
+                    # Handle common cases where we want to preserve the string
+                    if value.lower() in ['true', 'false']:
+                        parameters[key] = value.lower() == 'true'
+                    elif value.replace('.', '').replace('-', '').isdigit():
+                        # Check if it's a number
+                        if '.' in value:
+                            parameters[key] = float(value)
+                        else:
+                            parameters[key] = int(value)
+                    else:
+                        # Keep as string
+                        parameters[key] = value
+                except ValueError:
+                    # If JSON parsing fails, treat as string
+                    parameters[key] = value
 
         start_flow(
             url = args.api_url,

trustgraph_cli-1.4.14/trustgraph/cli_version.py

@@ -0,0 +1 @@
+__version__ = "1.4.14"

{trustgraph_cli-1.4.12 → trustgraph_cli-1.4.14}/trustgraph_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustgraph-cli
-Version: 1.4.12
+Version: 1.4.14
 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-1.4.12 → trustgraph_cli-1.4.14}/trustgraph_cli.egg-info/entry_points.txt

@@ -50,6 +50,7 @@ tg-show-kg-cores = trustgraph.cli.show_kg_cores:main
 tg-show-library-documents = trustgraph.cli.show_library_documents:main
 tg-show-library-processing = trustgraph.cli.show_library_processing:main
 tg-show-mcp-tools = trustgraph.cli.show_mcp_tools:main
+tg-show-parameter-types = trustgraph.cli.show_parameter_types:main
 tg-show-processor-state = trustgraph.cli.show_processor_state:main
 tg-show-prompts = trustgraph.cli.show_prompts:main
 tg-show-token-costs = trustgraph.cli.show_token_costs:main

trustgraph_cli-1.4.12/trustgraph/cli/show_flow_classes.py

@@ -1,67 +0,0 @@
-"""
-Shows all defined flow classes.
-"""
-
-import argparse
-import os
-import tabulate
-from trustgraph.api import Api
-import json
-
-default_url = os.getenv("TRUSTGRAPH_URL", 'http://localhost:8088/')
-
-def show_flow_classes(url):
-
-    api = Api(url).flow()
-
-    class_names = api.list_classes()
-
-    if len(class_names) == 0:
-        print("No flows.")
-        return
-
-    classes = []
-
-    for class_name in class_names:
-        cls = api.get_class(class_name)
-        classes.append((
-            class_name,
-            cls.get("description", ""),
-            ", ".join(cls.get("tags", [])),
-        ))
-
-    print(tabulate.tabulate(
-        classes,
-        tablefmt="pretty",
-        maxcolwidths=[None, 40, 20],
-        stralign="left",
-        headers = ["flow class", "description", "tags"],
-    ))
-
-def main():
-
-    parser = argparse.ArgumentParser(
-        prog='tg-show-flow-classes',
-        description=__doc__,
-    )
-
-    parser.add_argument(
-        '-u', '--api-url',
-        default=default_url,
-        help=f'API URL (default: {default_url})',
-    )
-
-    args = parser.parse_args()
-
-    try:
-
-        show_flow_classes(
-            url=args.api_url,
-        )
-
-    except Exception as e:
-
-        print("Exception:", e, flush=True)
-
-if __name__ == "__main__":
-    main()

trustgraph_cli-1.4.12/trustgraph/cli/show_flows.py

@@ -1,119 +0,0 @@
-"""
-Shows configured flows.
-"""
-
-import argparse
-import os
-import tabulate
-from trustgraph.api import Api, ConfigKey
-import json
-
-default_url = os.getenv("TRUSTGRAPH_URL", 'http://localhost:8088/')
-
-def get_interface(config_api, i):
-
-    key = ConfigKey("interface-descriptions", i)
-
-    value = config_api.get([key])[0].value
-
-    return json.loads(value)
-
-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]["request"]
-
-                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 show_flows(url):
-
-    api = Api(url)
-    config_api = api.config()
-    flow_api = api.flow()
-
-    interface_names = config_api.list("interface-descriptions")
-
-    interface_defs = {
-        i: get_interface(config_api, i)
-        for i in interface_names
-    }
-
-    flow_ids = flow_api.list()
-
-    if len(flow_ids) == 0:
-        print("No flows.")
-        return
-
-    flows = []
-
-    for id in flow_ids:
-
-        flow = flow_api.get(id)
-
-        table = []
-        table.append(("id", id))
-        table.append(("class", flow.get("class-name", "")))
-        table.append(("desc", flow.get("description", "")))
-
-        # Display parameters if they exist
-        parameters = flow.get("parameters", {})
-        if parameters:
-            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})',
-    )
-
-    args = parser.parse_args()
-
-    try:
-
-        show_flows(
-            url=args.api_url,
-        )
-
-    except Exception as e:
-
-        print("Exception:", e, flush=True)
-
-if __name__ == "__main__":
-    main()

trustgraph_cli-1.4.12/trustgraph/cli_version.py

@@ -1 +0,0 @@
-__version__ = "1.4.12"