Download tests/test_dependency_executor.py from polyHedra/PolyHedra: direct link, hf CLI and curl.
- Browser
- Download file 7.3 kB
-
https://huggingface.co/spaces/polyHedra/PolyHedra/resolve/main/tests/test_dependency_executor.py
- Command line
-
hf download hf://spaces/polyHedra/PolyHedra/tests/test_dependency_executor.py
-
curl -L -o test_dependency_executor.py https://huggingface.co/spaces/polyHedra/PolyHedra/resolve/main/tests/test_dependency_executor.py
7.3 kB
| """Dependency execution uses publication state, not linear mention routing.""" | |
| import asyncio | |
| import pytest | |
| from polyhedra.core.active_routing import build_active_routing_plan | |
| from polyhedra.core.artifacts import JsonArtifactRef | |
| from polyhedra.core.dependency_executor import AgentCompletion, DependencyExecutor | |
| from polyhedra.core.quant_contracts import load_quant_contracts | |
| def plan(tickers): | |
| return build_active_routing_plan(run_id="run1", execution_context="YOLO", tickers=list(tickers)) | |
| def completion(agent, status="COMPLETE", *, run="run1", session="session1"): | |
| contract = load_quant_contracts().for_agent(agent) | |
| path = next(path for path in contract.permissions.create if path.endswith(".json")) | |
| path = path.replace("{run_id}", run) | |
| return AgentCompletion( | |
| result_status=status, | |
| artifact_ref=JsonArtifactRef( | |
| schema_version="8.0", | |
| artifact_id=f"{agent}-{run}", | |
| run_id=run, | |
| session_id=session, | |
| producer=agent, | |
| path=path, | |
| ), | |
| ) | |
| async def test_ready_agents_overlap_and_join_waits_for_all_applicable_dependencies(): | |
| active = plan(["MSFT"]) | |
| data_done = asyncio.Event() | |
| branch_started = {"TrendAnalyst": asyncio.Event(), "SentimentAnalyst": asyncio.Event()} | |
| branch_release = asyncio.Event() | |
| starts = [] | |
| async def runner(item): | |
| starts.append(item.agent) | |
| if item.agent == "DataFetcher": | |
| data_done.set() | |
| elif item.agent in branch_started: | |
| assert data_done.is_set() | |
| branch_started[item.agent].set() | |
| await branch_release.wait() | |
| elif item.agent == "QuantResearcher": | |
| assert all(event.is_set() for event in branch_started.values()) | |
| return completion(item.agent) | |
| task = asyncio.create_task(DependencyExecutor( | |
| active, session_id="session1", runner=runner, | |
| ).run()) | |
| await asyncio.wait_for(data_done.wait(), timeout=1) | |
| await asyncio.wait_for(branch_started["TrendAnalyst"].wait(), timeout=1) | |
| await asyncio.wait_for(branch_started["SentimentAnalyst"].wait(), timeout=1) | |
| assert "QuantResearcher" not in starts | |
| branch_release.set() | |
| result = await asyncio.wait_for(task, timeout=1) | |
| assert all(record.state == "COMPLETED" for record in result.records) | |
| assert starts.index("TrendAnalyst") < starts.index("QuantResearcher") | |
| assert starts.index("SentimentAnalyst") < starts.index("QuantResearcher") | |
| async def test_unavailable_typed_result_satisfies_dependency_completion(): | |
| async def runner(item): | |
| status = "UNAVAILABLE" if item.agent == "TrendAnalyst" else "COMPLETE" | |
| return completion(item.agent, status) | |
| result = await DependencyExecutor( | |
| plan(["MSFT"]), session_id="session1", runner=runner, | |
| ).run() | |
| assert result.for_agent("TrendAnalyst").state == "COMPLETED" | |
| assert result.for_agent("TrendAnalyst").result_status == "UNAVAILABLE" | |
| assert result.for_agent("QuantResearcher").state == "COMPLETED" | |
| async def test_failure_blocks_dependents_but_unrelated_root_finishes(): | |
| completed = [] | |
| async def runner(item): | |
| if item.agent == "DataFetcher": | |
| raise RuntimeError("provider normalization failed") | |
| completed.append(item.agent) | |
| return completion(item.agent) | |
| result = await DependencyExecutor( | |
| plan(["SPY"]), session_id="session1", runner=runner, | |
| ).run() | |
| assert result.for_agent("DataFetcher").state == "FAILED" | |
| assert result.for_agent("OptionsFlowWatcher").state == "COMPLETED" | |
| assert completed == ["OptionsFlowWatcher"] | |
| assert result.for_agent("TrendAnalyst").blocked_by == ("DataFetcher",) | |
| assert result.for_agent("Publisher").state == "BLOCKED" | |
| async def test_wrong_publication_identity_is_execution_failure(): | |
| async def runner(item): | |
| if item.agent == "DataFetcher": | |
| return completion(item.agent, run="other") | |
| return completion(item.agent) | |
| result = await DependencyExecutor( | |
| plan(["MSFT"]), session_id="session1", runner=runner, | |
| ).run() | |
| record = result.for_agent("DataFetcher") | |
| assert record.state == "FAILED" | |
| assert "identity contradicts" in record.error | |
| assert result.for_agent("TrendAnalyst").state == "BLOCKED" | |
| async def test_each_active_agent_is_invoked_once(): | |
| calls = {} | |
| async def runner(item): | |
| calls[item.agent] = calls.get(item.agent, 0) + 1 | |
| return completion(item.agent) | |
| active = plan(["SPY", "BTC"]) | |
| result = await DependencyExecutor( | |
| active, session_id="session1", runner=runner, | |
| ).run() | |
| assert set(calls) == {item.agent for item in active.active_agents} | |
| assert set(calls.values()) == {1} | |
| assert len(result.records) == len(active.active_agents) | |
| async def test_inputs_are_captured_before_ready_tasks_are_scheduled(): | |
| captured = {} | |
| runner_mutations = [] | |
| def capture(item, dependencies): | |
| captured[item.agent] = ( | |
| tuple(record.agent for record in dependencies), tuple(runner_mutations), | |
| ) | |
| return f"snapshot:{item.agent}" | |
| async def runner(item, snapshot): | |
| assert snapshot == f"snapshot:{item.agent}" | |
| runner_mutations.append(item.agent) | |
| return completion(item.agent) | |
| result = await DependencyExecutor( | |
| plan(["MSFT"]), session_id="session1", runner=runner, input_capture=capture, | |
| ).run() | |
| assert all(record.state == "COMPLETED" for record in result.records) | |
| assert captured["DataFetcher"] == ((), ()) | |
| assert captured["TrendAnalyst"][0] == ("DataFetcher",) | |
| assert captured["SentimentAnalyst"][0] == ("DataFetcher",) | |
| assert captured["TrendAnalyst"][1] == captured["SentimentAnalyst"][1] | |
| async def test_input_capture_failure_blocks_only_dependent_branch(): | |
| ran = [] | |
| def capture(item, dependencies): | |
| if item.agent == "DataFetcher": | |
| raise ValueError("invalid provider artifact") | |
| return tuple(record.agent for record in dependencies) | |
| async def runner(item, _snapshot): | |
| ran.append(item.agent) | |
| return completion(item.agent) | |
| result = await DependencyExecutor( | |
| plan(["SPY"]), session_id="session1", runner=runner, input_capture=capture, | |
| ).run() | |
| assert result.for_agent("DataFetcher").state == "FAILED" | |
| assert "invalid provider artifact" in result.for_agent("DataFetcher").error | |
| assert result.for_agent("OptionsFlowWatcher").state == "COMPLETED" | |
| assert ran == ["OptionsFlowWatcher"] | |
| assert result.for_agent("Publisher").state == "BLOCKED" | |
| async def test_failed_execution_record_redacts_provider_credentials(): | |
| async def runner(item): | |
| raise RuntimeError( | |
| "https://provider.invalid/run?api_key=secret-value&mode=test " | |
| "Bearer private-token" | |
| ) | |
| result = await DependencyExecutor( | |
| plan(["SPY"]), session_id="session1", runner=runner, | |
| ).run() | |
| error = result.for_agent("DataFetcher").error | |
| assert "secret-value" not in error | |
| assert "private-token" not in error | |
| assert error.count("<redacted>") == 2 | |