virtual-context 0.3.6__tar.gz → 0.3.7__tar.gz

{virtual_context-0.3.6 → virtual_context-0.3.7}/.github/workflows/python-publish.yml

@@ -6,10 +6,14 @@ on:
 
 permissions:
   contents: read
+  id-token: write
 
 jobs:
   publish:
     runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/virtual-context
 
     steps:
       - uses: actions/checkout@v4
@@ -25,5 +29,3 @@ jobs:
 
       - name: Publish to PyPI
         uses: pypa/gh-action-pypi-publish@release/v1
-        with:
-          password: ${{ secrets.PYPI_API_TOKEN }}

{virtual_context-0.3.6 → virtual_context-0.3.7}/.gitignore

@@ -8,9 +8,6 @@ build/
 # Virtual environment
 .venv/
 
-# Infrastructure configs (contains secrets — never commit)
-infrastructure/
-
 # Testing
 .pytest_cache/
 

{virtual_context-0.3.6 → virtual_context-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: virtual-context
-Version: 0.3.6
+Version: 0.3.7
 Summary: OS-style virtual memory for LLM session context management
 Project-URL: Homepage, https://virtual-context.com
 Project-URL: Repository, https://github.com/virtual-context/virtual-context

{virtual_context-0.3.6 → virtual_context-0.3.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "virtual-context"
-version = "0.3.6"
+version = "0.3.7"
 description = "OS-style virtual memory for LLM session context management"
 readme = "README.md"
 license = "AGPL-3.0-or-later"

virtual_context-0.3.7/tests/test_beam_judge.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from benchmarks.beam.dataset import BEAMQuestion
+from benchmarks.beam.judge import judge_answer
+from benchmarks.beam.run_beam import _parse_args
+
+
+def _event_ordering_question() -> BEAMQuestion:
+    return BEAMQuestion(
+        question_id="10M_1_event_ordering_0",
+        question="Reconstruct the ordered sequence of milestones.",
+        category="event_ordering",
+        rubric=[
+            "token limits and segmentation",
+            "reranking and feedback parsing",
+            "language detection and vector alignment",
+        ],
+        ideal_response="",
+        difficulty="medium",
+    )
+
+
+def test_fast_event_ordering_judge_matches_paraphrases_without_llm(monkeypatch) -> None:
+    def _should_not_call(*args, **kwargs):
+        raise AssertionError("fast event ordering judge should not call the judge LLM")
+
+    monkeypatch.setattr("benchmarks.beam.judge._call_judge_llm", _should_not_call)
+
+    result = judge_answer(
+        _event_ordering_question(),
+        "\n".join([
+            "segmentation and token limit handling",
+            "feedback parsing plus reranking problems",
+            "vector alignment with language detection",
+        ]),
+        event_ordering_mode="fast",
+    )
+
+    assert result["method"] == "kendall_tau_fast"
+    assert result["score"] == 1.0
+    assert len(result["criteria_met"]) == 3
+
+
+def test_fast_event_ordering_judge_penalizes_wrong_order(monkeypatch) -> None:
+    def _should_not_call(*args, **kwargs):
+        raise AssertionError("fast event ordering judge should not call the judge LLM")
+
+    monkeypatch.setattr("benchmarks.beam.judge._call_judge_llm", _should_not_call)
+
+    result = judge_answer(
+        _event_ordering_question(),
+        "\n".join([
+            "vector alignment with language detection",
+            "feedback parsing plus reranking problems",
+            "segmentation and token limit handling",
+        ]),
+        event_ordering_mode="fast",
+    )
+
+    assert result["method"] == "kendall_tau_fast"
+    assert result["score"] < 1.0
+    assert result["tau_norm"] < 1.0
+
+
+def test_run_beam_parse_args_accepts_fast_event_ordering_mode() -> None:
+    args = _parse_args([
+        "--chat-size", "10M",
+        "--tagger-model", "claude-haiku-4-5-20251001",
+        "--event-ordering-judge-mode", "fast",
+    ])
+    assert args.event_ordering_judge_mode == "fast"
+
+
+def test_fast_event_ordering_judge_returns_zero_not_nan_for_no_matches(monkeypatch) -> None:
+    def _should_not_call(*args, **kwargs):
+        raise AssertionError("fast event ordering judge should not call the judge LLM")
+
+    monkeypatch.setattr("benchmarks.beam.judge._call_judge_llm", _should_not_call)
+
+    result = judge_answer(
+        _event_ordering_question(),
+        "\n".join([
+            "completely unrelated infrastructure planning",
+            "team retro and onboarding notes",
+        ]),
+        event_ordering_mode="fast",
+    )
+
+    assert result["method"] == "kendall_tau_fast"
+    assert isinstance(float(result["score"]), float)
+    assert result["score"] == result["score"]
+    assert result["alignments"] == []

virtual_context-0.3.7/tests/test_conversation_coverage_report.py

@@ -0,0 +1,145 @@
+from datetime import datetime, timezone
+
+from virtual_context.core.coverage_report import build_conversation_coverage_report
+from virtual_context.storage.sqlite import SQLiteStore
+from virtual_context.types import SegmentMetadata, StoredSegment, TagSummary
+
+
+def _make_segment(
+    ref: str,
+    *,
+    conversation_id: str,
+    turn_count: int,
+    start_turn_number: int,
+    end_turn_number: int,
+    generated_by_turn_id: str,
+    created_at: datetime,
+) -> StoredSegment:
+    return StoredSegment(
+        ref=ref,
+        conversation_id=conversation_id,
+        primary_tag="topic",
+        tags=["topic"],
+        summary=f"summary {ref}",
+        summary_tokens=10,
+        full_text=f"full {ref}",
+        full_tokens=20,
+        messages=[{"role": "user", "content": ref}],
+        metadata=SegmentMetadata(
+            turn_count=turn_count,
+            start_turn_number=start_turn_number,
+            end_turn_number=end_turn_number,
+            generated_by_turn_id=generated_by_turn_id,
+        ),
+        created_at=created_at,
+        start_timestamp=created_at,
+        end_timestamp=created_at,
+        compaction_model="test",
+        compression_ratio=0.5,
+    )
+
+
+def test_build_conversation_coverage_report_uses_latest_payload_and_exact_ranges(tmp_path):
+    store = SQLiteStore(tmp_path / "test.db")
+    conversation_id = "conv-1"
+    now = datetime(2026, 4, 10, 12, 0, tzinfo=timezone.utc)
+
+    store.store_segment(
+        _make_segment(
+            "seg-a",
+            conversation_id=conversation_id,
+            turn_count=3,
+            start_turn_number=0,
+            end_turn_number=2,
+            generated_by_turn_id="req-a",
+            created_at=now,
+        )
+    )
+    store.store_segment(
+        _make_segment(
+            "seg-b",
+            conversation_id=conversation_id,
+            turn_count=3,
+            start_turn_number=2,
+            end_turn_number=4,
+            generated_by_turn_id="req-b",
+            created_at=now.replace(hour=13),
+        )
+    )
+    store.store_segment(
+        _make_segment(
+            "seg-c",
+            conversation_id=conversation_id,
+            turn_count=4,
+            start_turn_number=-1,
+            end_turn_number=-1,
+            generated_by_turn_id="",
+            created_at=now.replace(hour=14),
+        )
+    )
+    store.save_tag_summary(
+        TagSummary(
+            tag="topic",
+            summary="rollup",
+            summary_tokens=12,
+            covers_through_turn=8,
+            generated_by_turn_id="req-b",
+            created_at=now.replace(hour=15),
+            updated_at=now.replace(hour=15),
+        ),
+        conversation_id=conversation_id,
+    )
+    store.save_request_capture(
+        {
+            "turn": 9,
+            "turn_id": "req-latest",
+            "ts": "2026-04-10T16:30:00+00:00",
+            "api_format": "anthropic",
+            "model": "test",
+            "stream": False,
+            "message_count": 6,
+            "client_payload_message_count": 6,
+            "client_payload_pair_count": 3,
+            "client_payload_user_prompt_count": 3,
+            "client_payload_timestamped_message_count": 3,
+            "client_payload_earliest_timestamp": "2026-03-15T16:10:00+00:00",
+            "client_payload_latest_timestamp": "2026-04-10T16:29:00+00:00",
+            "conversation_id": conversation_id,
+            "inbound_tags": [],
+            "response_tags": [],
+            "passthrough": False,
+            "inbound_tokens": 0,
+            "outbound_tokens": 0,
+            "inbound_bytes": 0,
+            "outbound_bytes": 0,
+            "context_tokens": 0,
+            "overhead_ms": 0,
+            "turns_dropped": 0,
+            "turns_stubbed": 0,
+            "message_preview": "",
+            "upstream_input_tokens": 0,
+            "upstream_output_tokens": 0,
+            "cache_creation_input_tokens": 0,
+            "cache_read_input_tokens": 0,
+        }
+    )
+
+    report = build_conversation_coverage_report(store, conversation_id)
+
+    assert report.conversation_id == conversation_id
+    assert report.latest_payload.turn == 9
+    assert report.latest_payload.turn_id == "req-latest"
+    assert report.latest_payload.message_count == 6
+    assert report.latest_payload.pair_count == 3
+    assert report.latest_payload.user_prompt_count == 3
+    assert report.latest_payload.timestamped_message_count == 3
+    assert report.latest_payload.earliest_timestamp == "2026-03-15T16:10:00+00:00"
+    assert report.latest_payload.latest_timestamp == "2026-04-10T16:29:00+00:00"
+    assert report.segment_count == 3
+    assert report.summarized_turn_occurrences == 10
+    assert report.exact_range_segment_count == 2
+    assert report.exact_unique_turn_count == 5
+    assert report.exact_start_turn_number == 0
+    assert report.exact_end_turn_number == 4
+    assert report.tag_summary_count == 1
+    assert report.max_tag_summary_turn == 8

{virtual_context-0.3.6 → virtual_context-0.3.7}/tests/test_engine_sync_turns.py

@@ -67,16 +67,16 @@ def engine(tmp_path):
 
 
 def _search_via_store(engine, query):
-    """Search turn_messages through the CompositeStore delegate (Task 1).
+    """Search canonical full_text through the CompositeStore delegate.
 
-    Validates that the CompositeStore.search_turn_messages delegation works,
+    Validates that the CompositeStore.search_canonical_full_text delegation works,
     not just the raw concrete store method.
     """
     store = engine._store
-    _search = getattr(store, "search_turn_messages", None)
+    _search = getattr(store, "search_canonical_full_text", None)
     assert _search is not None, (
-        "search_turn_messages not reachable through store chain — "
-        "CompositeStore delegation missing (Task 1)")
+        "search_canonical_full_text not reachable through store chain — "
+        "CompositeStore delegation missing")
     return _search(query, conversation_id="test-conv-sync")