trustgraph-cli 2.1.11__tar.gz → 2.1.13__tar.gz

{trustgraph_cli-2.1.11 → trustgraph_cli-2.1.13}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustgraph-cli
-Version: 2.1.11
+Version: 2.1.13
 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.1.11 → trustgraph_cli-2.1.13}/trustgraph/cli/invoke_graph_rag.py

@@ -36,14 +36,14 @@ RDFS_LABEL = "http://www.w3.org/2000/01/rdf-schema#label"
 
 def _get_event_type(prov_id):
     """Extract event type from provenance_id"""
-    if "session" in prov_id:
-        return "session"
-    elif "retrieval" in prov_id:
-        return "retrieval"
-    elif "selection" in prov_id:
-        return "selection"
-    elif "answer" in prov_id:
-        return "answer"
+    if "question" in prov_id:
+        return "question"
+    elif "exploration" in prov_id:
+        return "exploration"
+    elif "focus" in prov_id:
+        return "focus"
+    elif "synthesis" in prov_id:
+        return "synthesis"
     return "provenance"
 
 
@@ -51,7 +51,7 @@ def _format_provenance_details(event_type, triples):
     """Format provenance details based on event type and triples"""
     lines = []
 
-    if event_type == "session":
+    if event_type == "question":
         # Show query and timestamp
         for s, p, o in triples:
             if p == TG_QUERY:
@@ -59,32 +59,32 @@ def _format_provenance_details(event_type, triples):
             elif p == PROV_STARTED_AT_TIME:
                 lines.append(f"    Time: {o}")
 
-    elif event_type == "retrieval":
+    elif event_type == "exploration":
         # Show edge count
         for s, p, o in triples:
             if p == TG_EDGE_COUNT:
-                lines.append(f"    Edges retrieved: {o}")
+                lines.append(f"    Edges explored: {o}")
 
-    elif event_type == "selection":
-        # For selection, just count edge selection URIs
+    elif event_type == "focus":
+        # For focus, just count edge selection URIs
         # The actual edge details are fetched separately via edge_selections parameter
         edge_sel_uris = []
         for s, p, o in triples:
             if p == TG_SELECTED_EDGE:
                 edge_sel_uris.append(o)
         if edge_sel_uris:
-            lines.append(f"    Selected {len(edge_sel_uris)} edge(s)")
+            lines.append(f"    Focused on {len(edge_sel_uris)} edge(s)")
 
-    elif event_type == "answer":
+    elif event_type == "synthesis":
         # Show content length (not full content - it's already streamed)
         for s, p, o in triples:
             if p == TG_CONTENT:
-                lines.append(f"    Answer length: {len(o)} chars")
+                lines.append(f"    Synthesis length: {len(o)} chars")
 
     return lines
 
 
-async def _query_triples_once(ws_url, flow_id, prov_id, user, collection, debug=False):
+async def _query_triples_once(ws_url, flow_id, prov_id, user, collection, graph=None, debug=False):
     """Query triples for a provenance node (single attempt)"""
     request = {
         "id": "triples-request",
@@ -97,6 +97,9 @@ async def _query_triples_once(ws_url, flow_id, prov_id, user, collection, debug=
             "limit": 100
         }
     }
+    # Add graph filter if specified (for named graph queries)
+    if graph is not None:
+        request["request"]["g"] = graph
 
     if debug:
         print(f"    [debug] querying triples for s={prov_id}", file=sys.stderr)
@@ -155,10 +158,10 @@ async def _query_triples_once(ws_url, flow_id, prov_id, user, collection, debug=
     return triples
 
 
-async def _query_triples(ws_url, flow_id, prov_id, user, collection, max_retries=5, retry_delay=0.2, debug=False):
+async def _query_triples(ws_url, flow_id, prov_id, user, collection, graph=None, max_retries=5, retry_delay=0.2, debug=False):
     """Query triples for a provenance node with retries for race condition"""
     for attempt in range(max_retries):
-        triples = await _query_triples_once(ws_url, flow_id, prov_id, user, collection, debug)
+        triples = await _query_triples_once(ws_url, flow_id, prov_id, user, collection, graph=graph, debug=debug)
         if triples:
             return triples
         # Wait before retry if empty (triples may not be stored yet)
@@ -515,14 +518,14 @@ async def _question_explainable(
                 if message_type == "explain":
                     # Display explain event with details
                     explain_id = resp.get("explain_id", "")
-                    explain_collection = resp.get("explain_collection", "explainability")
+                    explain_graph = resp.get("explain_graph")  # Named graph (e.g., urn:graph:retrieval)
                     if explain_id:
                         event_type = _get_event_type(explain_id)
                         print(f"\n  [{event_type}] {explain_id}", file=sys.stderr)
 
-                        # Query triples for this explain node (using explain collection from event)
+                        # Query triples for this explain node (using named graph filter)
                         triples = await _query_triples(
-                            ws_url, flow_id, explain_id, user, explain_collection, debug=debug
+                            ws_url, flow_id, explain_id, user, collection, graph=explain_graph, debug=debug
                         )
 
                         # Format and display details
@@ -530,17 +533,17 @@ async def _question_explainable(
                         for line in details:
                             print(line, file=sys.stderr)
 
-                        # For selection events, query each edge selection for details
-                        if event_type == "selection":
+                        # For focus events, query each edge selection for details
+                        if event_type == "focus":
                             for s, p, o in triples:
                                 if debug:
                                     print(f"    [debug] triple: p={p}, o={o}, o_type={type(o).__name__}", file=sys.stderr)
                                 if p == TG_SELECTED_EDGE and isinstance(o, str):
                                     if debug:
                                         print(f"    [debug] querying edge selection: {o}", file=sys.stderr)
-                                    # Query the edge selection entity (using explain collection from event)
+                                    # Query the edge selection entity (using named graph filter)
                                     edge_triples = await _query_triples(
-                                        ws_url, flow_id, o, user, explain_collection, debug=debug
+                                        ws_url, flow_id, o, user, collection, graph=explain_graph, debug=debug
                                     )
                                     if debug:
                                         print(f"    [debug] got {len(edge_triples)} edge triples", file=sys.stderr)
@@ -743,7 +746,7 @@ def main():
     parser.add_argument(
         '-x', '--explainable',
         action='store_true',
-        help='Show provenance events for explainability (implies streaming)'
+        help='Show provenance events: Question, Exploration, Focus, Synthesis (implies streaming)'
     )
 
     parser.add_argument(

{trustgraph_cli-2.1.11 → trustgraph_cli-2.1.13}/trustgraph/cli/query_graph.py

@@ -186,6 +186,12 @@ def build_quoted_triple_term(qt_subject, qt_subject_type,
 def format_term(term_dict):
     """Format a term dict for display in space/pipe output formats.
 
+    Handles multiple wire format styles:
+    - Short form (send): {"t": "i", "i": "..."}, {"t": "l", "v": "..."}
+    - Long form (receive): {"type": "i", "iri": "..."}, {"type": "l", "value": "..."}
+    - Raw quoted triple: {"s": {...}, "p": {...}, "o": {...}} (no type wrapper)
+    - Stringified quoted triple in IRI: {"t": "i", "i": "{\"s\":...}"} (backend quirk)
+
     Args:
         term_dict: Wire-format term dict
 
@@ -195,25 +201,53 @@ def format_term(term_dict):
     if not term_dict:
         return ""
 
-    t = term_dict.get("t")
+    # Get type - handle both short and long form
+    t = term_dict.get("t") or term_dict.get("type")
+
     if t == "i":
-        return term_dict.get("i", "")
+        # IRI - handle both "i" and "iri" keys
+        iri_value = term_dict.get("i") or term_dict.get("iri", "")
+        # Check if IRI value is actually a stringified quoted triple (backend quirk)
+        if iri_value.startswith('{"s":') or iri_value.startswith("{\"s\":"):
+            try:
+                parsed = json.loads(iri_value)
+                if "s" in parsed and "p" in parsed and "o" in parsed:
+                    # It's a stringified quoted triple - format it properly
+                    s = format_term(parsed.get("s", {}))
+                    p = format_term(parsed.get("p", {}))
+                    o = format_term(parsed.get("o", {}))
+                    return f"<<{s} {p} {o}>>"
+            except json.JSONDecodeError:
+                pass  # Not valid JSON, treat as regular IRI
+        return iri_value
     elif t == "l":
-        value = term_dict.get("v", "")
-        # Quote literals and show language/datatype if present
+        # Literal - handle both short and long form keys
+        value = term_dict.get("v") or term_dict.get("value", "")
         result = f'"{value}"'
-        if "ln" in term_dict:
-            result += f'@{term_dict["ln"]}'
-        elif "dt" in term_dict:
-            result += f'^^{term_dict["dt"]}'
+        # Language tag
+        lang = term_dict.get("ln") or term_dict.get("language")
+        if lang:
+            result += f'@{lang}'
+        else:
+            # Datatype
+            dt = term_dict.get("dt") or term_dict.get("datatype")
+            if dt:
+                result += f'^^{dt}'
         return result
     elif t == "t":
-        # Format quoted triple as <<s p o>>
-        tr = term_dict.get("tr", {})
+        # Quoted triple - handle both "tr" and "triple" keys
+        tr = term_dict.get("tr") or term_dict.get("triple", {})
         s = format_term(tr.get("s", {}))
         p = format_term(tr.get("p", {}))
         o = format_term(tr.get("o", {}))
         return f"<<{s} {p} {o}>>"
+    elif t is None and "s" in term_dict and "p" in term_dict and "o" in term_dict:
+        # Raw quoted triple without type wrapper (has s, p, o keys directly)
+        s = format_term(term_dict.get("s", {}))
+        p = format_term(term_dict.get("p", {}))
+        o = format_term(term_dict.get("o", {}))
+        return f"<<{s} {p} {o}>>"
+
     return str(term_dict)
 
 
@@ -526,8 +560,9 @@ def main():
         else:
             obj_term = None
 
-        # Graph is always an IRI
-        graph_term = build_term(args.graph, term_type='iri') if args.graph else None
+        # Graph is a plain IRI string, not a Term
+        # None = all graphs, "" = default graph only, "uri" = specific graph
+        graph_value = args.graph
 
         query_graph(
             url=args.api_url,
@@ -539,7 +574,7 @@ def main():
             subject=subject_term,
             predicate=predicate_term,
             obj=obj_term,
-            graph=graph_term,
+            graph=graph_value,
             output_format=args.format,
             headers=args.headers,
             token=args.token,

{trustgraph_cli-2.1.11 → trustgraph_cli-2.1.13}/trustgraph/cli/show_graph.py

@@ -1,6 +1,11 @@
 """
 Connects to the graph query service and dumps all graph edges.
 Uses streaming mode for lower time-to-first-result and reduced memory overhead.
+
+Named graphs:
+  - Default graph (empty): Core knowledge facts
+  - urn:graph:source: Extraction provenance (document/chunk sources)
+  - urn:graph:retrieval: Query-time explainability (question, exploration, focus, synthesis)
 """
 
 import argparse
@@ -12,7 +17,13 @@ default_user = 'trustgraph'
 default_collection = 'default'
 default_token = os.getenv("TRUSTGRAPH_TOKEN", None)
 
-def show_graph(url, flow_id, user, collection, limit, batch_size, token=None):
+# Named graph constants for convenience
+GRAPH_DEFAULT = ""
+GRAPH_SOURCE = "urn:graph:source"
+GRAPH_RETRIEVAL = "urn:graph:retrieval"
+
+
+def show_graph(url, flow_id, user, collection, limit, batch_size, graph=None, show_graph_column=False, token=None):
 
     socket = Api(url, token=token).socket()
     flow = socket.flow(flow_id)
@@ -22,6 +33,7 @@ def show_graph(url, flow_id, user, collection, limit, batch_size, token=None):
             user=user,
             collection=collection,
             s=None, p=None, o=None,
+            g=graph,  # Filter by named graph (None = all graphs)
             limit=limit,
             batch_size=batch_size,
         ):
@@ -29,11 +41,16 @@ def show_graph(url, flow_id, user, collection, limit, batch_size, token=None):
                 s = triple.get("s", {})
                 p = triple.get("p", {})
                 o = triple.get("o", {})
+                g = triple.get("g")  # Named graph (None = default graph)
                 # Format terms for display
                 s_str = s.get("v", s.get("i", str(s)))
                 p_str = p.get("v", p.get("i", str(p)))
                 o_str = o.get("v", o.get("i", str(o)))
-                print(s_str, p_str, o_str)
+                if show_graph_column:
+                    g_str = g if g else "(default)"
+                    print(f"[{g_str}]", s_str, p_str, o_str)
+                else:
+                    print(s_str, p_str, o_str)
     finally:
         socket.close()
 
@@ -88,8 +105,25 @@ def main():
         help='Triples per streaming batch (default: 20)',
     )
 
+    parser.add_argument(
+        '-g', '--graph',
+        default=None,
+        help='Filter by named graph (e.g., urn:graph:source, urn:graph:retrieval). Use "" for default graph only.',
+    )
+
+    parser.add_argument(
+        '--show-graph',
+        action='store_true',
+        help='Show graph column in output',
+    )
+
     args = parser.parse_args()
 
+    # Handle empty string for default graph filter
+    graph = args.graph
+    if graph == '""' or graph == "''":
+        graph = ""  # Filter to default graph only
+
     try:
 
         show_graph(
@@ -99,6 +133,8 @@ def main():
             collection = args.collection,
             limit = args.limit,
             batch_size = args.batch_size,
+            graph = graph,
+            show_graph_column = args.show_graph,
             token = args.token,
         )
 

trustgraph_cli-2.1.13/trustgraph/cli_version.py

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

{trustgraph_cli-2.1.11 → trustgraph_cli-2.1.13}/trustgraph_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: trustgraph-cli
-Version: 2.1.11
+Version: 2.1.13
 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.1.11/trustgraph/cli_version.py

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