activegraph 1.0.3__tar.gz → 1.0.4__tar.gz

{activegraph-1.0.3 → activegraph-1.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: activegraph
-Version: 1.0.3
+Version: 1.0.4
 Summary: An event-sourced reactive graph runtime for long-running, auditable, agentic systems.
 Author: Active Graph contributors
 License: MIT

{activegraph-1.0.3 → activegraph-1.0.4}/activegraph/__init__.py

@@ -222,4 +222,4 @@ __all__ = [
     "tool",
 ]
 
-__version__ = "1.0.3"
+__version__ = "1.0.4"

{activegraph-1.0.3 → activegraph-1.0.4}/activegraph/core/graph.py

@@ -181,6 +181,33 @@ class Graph:
             out.append(r)
         return out
 
+    def relations(
+        self,
+        source: Optional[str] = None,
+        target: Optional[str] = None,
+        type: Optional[str] = None,
+    ) -> list[Relation]:
+        """Return relations filtered by ``source``, ``target``, and/or ``type``.
+
+        v1.0.4 #1: the canonical filter API on ``Graph``. Decomposes the
+        v0 ``get_relations(object_id=, direction=)`` axis into separate
+        ``source`` and ``target`` slots so the call reads the way users
+        already write it (matches ``docs/concepts/graph.md``). Filter
+        kwargs compose by AND; calling with no kwargs returns every
+        relation. ``Graph.get_relations(object_id=, type=, direction=)``
+        stays as a backward-compatible alias.
+        """
+        out: list[Relation] = []
+        for r in self._relations.values():
+            if source is not None and r.source != source:
+                continue
+            if target is not None and r.target != target:
+                continue
+            if type is not None and r.type != type:
+                continue
+            out.append(r)
+        return out
+
     def neighborhood(self, object_id: str, depth: int = 1) -> tuple[list[Object], list[Relation]]:
         if object_id not in self._objects:
             return ([], [])

{activegraph-1.0.3 → activegraph-1.0.4}/activegraph.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: activegraph
-Version: 1.0.3
+Version: 1.0.4
 Summary: An event-sourced reactive graph runtime for long-running, auditable, agentic systems.
 Author: Active Graph contributors
 License: MIT

{activegraph-1.0.3 → activegraph-1.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "activegraph"
-version = "1.0.3"
+version = "1.0.4"
 description = "An event-sourced reactive graph runtime for long-running, auditable, agentic systems."
 readme = "README.md"
 requires-python = ">=3.11"

{activegraph-1.0.3 → activegraph-1.0.4}/tests/test_graph.py

@@ -129,6 +129,104 @@ def test_query_alias_still_works_with_positional_arg():
     assert {o.type for o in g.query("claim")} == {"claim"}
 
 
+# v1.0.4 #1: graph.relations(source=, target=, type=) as the canonical
+# filter API, decomposing the v0 get_relations(object_id=, direction=)
+# axis into separate source/target slots. The contract claim is the
+# eight filter combinations enumerated in CONTRACT v1.0.4 #1; the tests
+# anchor on each combination directly, not on equivalence to the alias.
+# The alias-still-works check is its own test.
+
+
+def _three_node_graph():
+    g = _g()
+    a = g.add_object("task", {"k": "a"})
+    b = g.add_object("task", {"k": "b"})
+    c = g.add_object("task", {"k": "c"})
+    rel_ab_dep = g.add_relation(a.id, b.id, "depends_on")
+    rel_ac_dep = g.add_relation(a.id, c.id, "depends_on")
+    rel_bc_blk = g.add_relation(b.id, c.id, "blocks")
+    rel_ba_dep = g.add_relation(b.id, a.id, "depends_on")
+    return g, a, b, c, rel_ab_dep, rel_ac_dep, rel_bc_blk, rel_ba_dep
+
+
+def test_relations_no_kwargs_returns_every_relation():
+    # Contract row 1: (None, None, None) -> every relation.
+    g, _, _, _, *rels = _three_node_graph()
+    out = g.relations()
+    assert {r.id for r in out} == {r.id for r in rels}
+
+
+def test_relations_source_only_returns_outgoing_from_source():
+    # Contract row 2: (A, None, None) -> relations where source == A.
+    g, a, b, c, rel_ab, rel_ac, _, _ = _three_node_graph()
+    out = g.relations(source=a.id)
+    assert {r.id for r in out} == {rel_ab.id, rel_ac.id}
+    assert all(r.source == a.id for r in out)
+
+
+def test_relations_target_only_returns_incoming_to_target():
+    # Contract row 3: (None, B, None) -> relations where target == B.
+    g, a, b, c, rel_ab, _, _, _ = _three_node_graph()
+    out = g.relations(target=b.id)
+    assert {r.id for r in out} == {rel_ab.id}
+    assert all(r.target == b.id for r in out)
+
+
+def test_relations_source_and_target_returns_intersection():
+    # Contract row 4: (A, B, None) -> relations from A to B.
+    g, a, b, c, rel_ab, _, _, rel_ba = _three_node_graph()
+    out = g.relations(source=a.id, target=b.id)
+    assert {r.id for r in out} == {rel_ab.id}
+    # Not the reverse direction.
+    assert rel_ba.id not in {r.id for r in out}
+
+
+def test_relations_type_only_returns_every_relation_of_type():
+    # Contract row 5: (None, None, T) -> every relation of type T.
+    g, *_, rel_bc_blk, _ = _three_node_graph()
+    out = g.relations(type="blocks")
+    assert {r.id for r in out} == {rel_bc_blk.id}
+    assert all(r.type == "blocks" for r in out)
+
+
+def test_relations_source_and_type_returns_outgoing_of_type():
+    # Contract row 6: (A, None, T) -> relations from A of type T.
+    g, a, _, _, rel_ab, rel_ac, _, _ = _three_node_graph()
+    out = g.relations(source=a.id, type="depends_on")
+    assert {r.id for r in out} == {rel_ab.id, rel_ac.id}
+
+
+def test_relations_target_and_type_returns_incoming_of_type():
+    # Contract row 7: (None, B, T) -> relations to B of type T.
+    g, a, b, _, rel_ab, _, _, _ = _three_node_graph()
+    out = g.relations(target=b.id, type="depends_on")
+    assert {r.id for r in out} == {rel_ab.id}
+
+
+def test_relations_source_target_and_type_most_specific():
+    # Contract row 8: (A, B, T) -> relations from A to B of type T.
+    g, a, b, _, rel_ab, _, _, rel_ba = _three_node_graph()
+    out = g.relations(source=a.id, target=b.id, type="depends_on")
+    assert {r.id for r in out} == {rel_ab.id}
+    # Different-direction same-type relation is excluded.
+    assert rel_ba.id not in {r.id for r in out}
+    # Wrong-type from A->B does not exist; sanity check empty for a wrong type.
+    assert g.relations(source=a.id, target=b.id, type="blocks") == []
+
+
+def test_get_relations_alias_still_works():
+    # Backward-compat: the v0 shape continues to work byte-identically.
+    # This is the alias relationship, not the contract claim — kept as
+    # its own test per CONTRACT v1.0.4 #1's Standing Rule §2 carve-out.
+    g, a, b, c, rel_ab, rel_ac, _, rel_ba = _three_node_graph()
+    out = g.get_relations(object_id=a.id, direction="outgoing")
+    assert {r.id for r in out} == {rel_ab.id, rel_ac.id}
+    incoming = g.get_relations(object_id=a.id, direction="incoming")
+    assert {r.id for r in incoming} == {rel_ba.id}
+    both = g.get_relations(object_id=a.id, direction="both")
+    assert {r.id for r in both} == {rel_ab.id, rel_ac.id, rel_ba.id}
+
+
 def test_neighborhood_walks_to_depth():
     g = _g()
     a = g.add_object("task", {})

{activegraph-1.0.3 → activegraph-1.0.4}/tests/test_requeue_unfired.py

@@ -128,6 +128,70 @@ class TestRequeueUnfiredDoesNotFalselyRequeue:
                 except FileNotFoundError:
                     pass
 
+    def test_zero_subscriber_event_ids_are_absent_from_requeue_set_on_load(self):
+        """Boundary-anchored sibling to the queue_depth assertion above.
+
+        CONTRACT v0.5 #8 names the boundary as `Runtime.load` and the
+        subject as the requeue set itself: "events with NO
+        `behavior.started` referencing them are re-queued; events that
+        any behavior started on are NOT re-queued." A zero-subscriber
+        event has no `behavior.started` referencing it but is
+        popped-and-discarded by the runtime loop — so the contract
+        carve-out is that zero-subscriber events are NOT in the
+        requeue set on load.
+
+        The sibling test above asserts `queue_depth == 0` (the
+        implementation's symptom). This test asserts directly on the
+        boundary the contract names: it identifies the zero-subscriber
+        event IDs from the saved log, reloads, and verifies those IDs
+        are absent from `rt._queue` after `_requeue_unfired` ran on
+        load. Anchors on what the contract says, not on whether the
+        post-load queue depth happens to be zero (CONTRACT v1.0.4 #4,
+        Standing Rule §2).
+        """
+        _register_subscriber_for_goal_only()
+        with tempfile.NamedTemporaryFile(suffix=".db", delete=False) as f:
+            path = f.name
+        os.remove(path)
+        try:
+            g = Graph()
+            rt = Runtime(g, persist_to=path)
+            rt.run_goal("test_goal")
+            rt.save_state()
+
+            zero_subscriber_event_ids = {
+                e.id for e in rt.graph.events
+                if e.type == "downstream.no_subscribers"
+            }
+            assert zero_subscriber_event_ids, (
+                "Fixture is supposed to produce at least one "
+                "downstream.no_subscribers event. Without it, the "
+                "contract claim's specific subject (the zero-"
+                "subscriber carve-out) isn't being exercised."
+            )
+
+            _register_subscriber_for_goal_only()
+            rt2 = Runtime.load(path, run_id=rt.run_id)
+
+            requeued_event_ids = {e.id for e in rt2._queue._q}  # noqa: SLF001
+            falsely_requeued = zero_subscriber_event_ids & requeued_event_ids
+            assert not falsely_requeued, (
+                f"CONTRACT v0.5 #8 carve-out: zero-subscriber events are "
+                f"popped-and-discarded with no behavior.started emitted, "
+                f"so on Runtime.load they must NOT appear in the requeue "
+                f"set. The following zero-subscriber event IDs were "
+                f"falsely requeued: {sorted(falsely_requeued)}. This is "
+                f"the v0.5 #8 boundary the contract names; failure here "
+                f"means the requeue set itself violates the contract "
+                f"regardless of what queue_depth summarizes."
+            )
+        finally:
+            for suffix in ("", "-wal", "-shm"):
+                try:
+                    os.remove(path + suffix)
+                except FileNotFoundError:
+                    pass
+
 
 class TestRequeueUnfiredPreservesCrashRecovery:
     """The fix narrows the requeue scope to events after the last drain.