doxa-ai 0.1.0__tar.gz

doxa_ai-0.1.0/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: doxa-ai
+Version: 0.1.0
+Summary: Doxa backend engine and CLI
+Author: VincenzoManto
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: click
+
+# Doxa
+
+Backend engine and CLI for Doxa.
+
+## Installazione locale
+
+```bash
+pip install .
+```
+
+## Utilizzo
+
+```bash
+doxa run
+```

doxa_ai-0.1.0/README.md

@@ -0,0 +1,15 @@
+# Doxa
+
+Backend engine and CLI for Doxa.
+
+## Installazione locale
+
+```bash
+pip install .
+```
+
+## Utilizzo
+
+```bash
+doxa run
+```

doxa_ai-0.1.0/pyproject.toml

@@ -0,0 +1,21 @@
+[tool.setuptools.packages.find]
+where = ["src"]
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "doxa-ai"
+version = "0.1.0"
+description = "Doxa backend engine and CLI"
+authors = [
+    { name = "VincenzoManto" }
+]
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "click"
+]
+
+[project.scripts]
+doxa = "doxa.cli:main"

doxa_ai-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

doxa_ai-0.1.0/src/doxa/__init__.py

@@ -0,0 +1 @@
+# Doxa package init

doxa_ai-0.1.0/src/doxa/cli.py

@@ -0,0 +1,14 @@
+import click
+
+@click.group()
+def main():
+    """Doxa CLI entry point."""
+    pass
+
+@main.command()
+def run():
+    """Run the Doxa backend engine."""
+    click.echo("Doxa engine running...")
+
+if __name__ == "__main__":
+    main()

doxa_ai-0.1.0/src/doxa_ai.egg-info/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: doxa-ai
+Version: 0.1.0
+Summary: Doxa backend engine and CLI
+Author: VincenzoManto
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: click
+
+# Doxa
+
+Backend engine and CLI for Doxa.
+
+## Installazione locale
+
+```bash
+pip install .
+```
+
+## Utilizzo
+
+```bash
+doxa run
+```

doxa_ai-0.1.0/src/doxa_ai.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+pyproject.toml
+src/doxa/__init__.py
+src/doxa/cli.py
+src/doxa_ai.egg-info/PKG-INFO
+src/doxa_ai.egg-info/SOURCES.txt
+src/doxa_ai.egg-info/dependency_links.txt
+src/doxa_ai.egg-info/entry_points.txt
+src/doxa_ai.egg-info/requires.txt
+src/doxa_ai.egg-info/top_level.txt
+tests/test_agent_economics.py
+tests/test_api.py
+tests/test_engine_smoke.py
+tests/test_market_engine.py
+tests/test_relation_graph.py
+tests/test_scenarios.py
+tests/test_world_events.py

doxa_ai-0.1.0/src/doxa_ai.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

doxa_ai-0.1.0/src/doxa_ai.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+doxa = doxa.cli:main

doxa_ai-0.1.0/src/doxa_ai.egg-info/requires.txt

@@ -0,0 +1 @@
+click

doxa_ai-0.1.0/src/doxa_ai.egg-info/top_level.txt

@@ -0,0 +1 @@
+doxa

doxa_ai-0.1.0/tests/test_agent_economics.py

@@ -0,0 +1,73 @@
+import pytest
+
+from engine.agents.AgentEconomics import AgentEconomics
+
+
+def test_compute_utility_uses_reference_prices_when_provided():
+    economics = AgentEconomics()
+    portfolio = {"credits": 10.0, "gold": 2.0, "panic": 0.5}
+
+    utility = economics.compute_utility(
+        portfolio,
+        {"credits": 1.0, "gold": 5.0, "panic": 0.0},
+    )
+
+    assert utility == 20.0
+
+
+def test_simulate_portfolio_delta_does_not_mutate_original():
+    economics = AgentEconomics()
+    portfolio = {"credits": 10.0, "gold": 2.0}
+
+    simulated = economics.simulate_portfolio_delta(portfolio, {"gold": -1.0, "corn": 4.0})
+
+    assert portfolio == {"credits": 10.0, "gold": 2.0}
+    assert simulated == {"credits": 10.0, "gold": 1.0, "corn": 4.0}
+
+
+def test_evaluate_trade_utility_returns_positive_delta_for_favorable_trade():
+    economics = AgentEconomics()
+    portfolio = {"credits": 10.0, "gold": 1.0}
+    reference_prices = {"credits": 1.0, "gold": 5.0, "corn": 2.5}
+
+    delta = economics.evaluate_trade_utility(
+        portfolio,
+        {"credits": 4.0},
+        {"corn": 3.0},
+        reference_prices,
+    )
+
+    assert delta == 3.5
+
+
+def test_evaluate_order_utility_handles_bid_and_ask():
+    economics = AgentEconomics()
+    portfolio = {"credits": 20.0, "gold": 4.0}
+    reference_prices = {"credits": 1.0, "gold": 6.0}
+
+    bid_delta = economics.evaluate_order_utility(
+        portfolio,
+        "bid",
+        "gold",
+        quantity=2.0,
+        price=5.0,
+        reference_prices=reference_prices,
+    )
+    ask_delta = economics.evaluate_order_utility(
+        portfolio,
+        "ask",
+        "gold",
+        quantity=2.0,
+        price=7.0,
+        reference_prices=reference_prices,
+    )
+
+    assert bid_delta == 2.0
+    assert ask_delta == 2.0
+
+
+def test_evaluate_order_utility_rejects_invalid_side():
+    economics = AgentEconomics()
+
+    with pytest.raises(ValueError):
+        economics.evaluate_order_utility({"credits": 10.0}, "hold", "gold", 1.0, 5.0)

doxa_ai-0.1.0/tests/test_api.py

@@ -0,0 +1,92 @@
+from fastapi.testclient import TestClient
+
+import api
+
+
+class StubEngine:
+    def __init__(self):
+        self.env = type("Env", (), {"pending_trades": {}})()
+        self.loaded_paths = []
+
+    def record_event(self, payload):
+        return payload
+
+    def make_ws_snapshot(self):
+        return None
+
+    def get_status(self):
+        return {"state": "idle", "epoch": 0, "step": 0}
+
+    def get_markets(self):
+        return {"gold": {"resource": "gold", "price": 10.0}}
+
+    def get_market_orderbook(self, resource, depth):
+        if resource != "gold":
+            return None
+        return {"resource": resource, "depth": depth, "bids": [], "asks": []}
+
+    def get_market_price_history(self, resource):
+        return {"resource": resource, "history": [10.0]} if resource == "gold" else None
+
+    def get_relations(self):
+        return [{"source": "alice", "target": "bob", "trust": 0.6, "type": "neutral"}]
+
+    def validate_yaml(self, yaml_text):
+        if not yaml_text.strip():
+            raise ValueError("empty config")
+        return {"valid": True, "config": {"raw": yaml_text}}
+
+    def load_config_path(self, path):
+        self.loaded_paths.append(path)
+        return {"source": {"kind": "path", "value": path}}
+
+    def update_config_text(self, yaml_text):
+        if yaml_text == "busy":
+            raise RuntimeError("engine busy")
+        return {"source": {"kind": "text", "value": "api"}}
+
+
+def _make_client(monkeypatch):
+    stub = StubEngine()
+    monkeypatch.setattr(api, "engine", stub)
+    monkeypatch.setattr(api, "publish_event", lambda payload: payload)
+    client = TestClient(api.app)
+    return client, stub
+
+
+def test_status_markets_and_relations_endpoints(monkeypatch):
+    client, _stub = _make_client(monkeypatch)
+
+    assert client.get("/api/status").json()["state"] == "idle"
+    assert "gold" in client.get("/api/markets").json()["markets"]
+    assert client.get("/api/relations").json()["relations"][0]["source"] == "alice"
+
+
+def test_market_orderbook_returns_404_for_unknown_market(monkeypatch):
+    client, _stub = _make_client(monkeypatch)
+
+    response = client.get("/api/markets/corn/orderbook")
+
+    assert response.status_code == 404
+    assert response.json()["error"] == "No market for 'corn'"
+
+
+def test_validate_and_load_config_endpoints(monkeypatch):
+    client, stub = _make_client(monkeypatch)
+
+    validate_response = client.post("/api/config/validate", json={"yaml_text": "actors: []"})
+    load_response = client.post("/api/config/load", json={"path": "scenarios/hormuz.yaml"})
+
+    assert validate_response.status_code == 200
+    assert validate_response.json()["valid"] is True
+    assert load_response.status_code == 200
+    assert stub.loaded_paths == ["scenarios/hormuz.yaml"]
+
+
+def test_update_config_returns_conflict_on_runtime_error(monkeypatch):
+    client, _stub = _make_client(monkeypatch)
+
+    response = client.put("/api/config", json={"yaml_text": "busy"})
+
+    assert response.status_code == 409
+    assert response.json()["detail"] == "engine busy"

doxa_ai-0.1.0/tests/test_engine_smoke.py

@@ -0,0 +1,37 @@
+from importlib import import_module
+from pathlib import Path
+
+import pytest
+
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+SCENARIO_FILES = sorted((REPO_ROOT / "scenarios").glob("*.yaml"))
+
+
+class DummyChatbot:
+    def __init__(self, engine):
+        self.engine = engine
+
+
+@pytest.fixture
+def doxa_engine_module(monkeypatch):
+    module = import_module("engine.DoxaEngine")
+    monkeypatch.setattr(module, "DoxaChatbot", DummyChatbot)
+    monkeypatch.setattr(module.DoxaEngine, "startOllama", lambda self: None)
+    return module
+
+
+def test_scenario_directory_contains_baseline_hormuz():
+    assert (REPO_ROOT / "scenarios" / "hormuz.yaml").exists()
+
+
+def test_engine_can_instantiate_against_all_launch_scenarios(doxa_engine_module):
+    assert SCENARIO_FILES, "Expected launch scenarios under scenarios/"
+
+    for scenario_path in SCENARIO_FILES:
+        yaml_text = scenario_path.read_text(encoding="utf-8")
+        engine = doxa_engine_module.DoxaEngine(yaml_text, log_verbose=False)
+
+        assert engine.raw_config["actors"]
+        assert engine.get_config()["config"]["actors"]
+        assert engine.validate_yaml(yaml_text)["valid"] is True

doxa_ai-0.1.0/tests/test_market_engine.py

@@ -0,0 +1,554 @@
+"""
+test_market_engine.py
+---------------------
+Comprehensive unit tests for market.MarketEngine.
+
+Coverage
+~~~~~~~~
+* Order reservation (bid/ask)         — insufficient-funds rejection
+* Continuous (FIFO) clearing          — exact fill, partial fill, price policies
+* Cancel + refund
+* Expire + refund (TTL)
+* Call-auction clearing               — volume-maximising uniform price
+* Market orders                       — slippage pricing + immediate clear
+* Per-market lock independence        — reads on different markets don't serialise
+* Thread-safety stress                — concurrent bids/asks from many threads
+"""
+
+import threading
+import time
+from market.MarketEngine import MarketEngine  # type: ignore[import]
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Helpers
+# ──────────────────────────────────────────────────────────────────────────────
+
+def _make_engine(resources=None, clearing="continuous", extra_cfg=None):
+    """Return a MarketEngine with one market per resource name.
+
+    Args:
+        resources: list of resource names (default: ["gold"])
+        clearing:  "continuous", "on_order", or "call_auction"
+        extra_cfg: dict of extra per-market config items (e.g. execution_price_policy)
+    """
+    resources = resources or ["gold"]
+    cfg = {}
+    if extra_cfg:
+        cfg.update(extra_cfg)
+    markets_cfg = [
+        {
+            "resource": r,
+            "currency": "credits",
+            "initial_price": 10.0,
+            "min_price": 1.0,
+            "max_price": 1000.0,
+            "clearing": clearing,
+            **cfg,
+        }
+        for r in resources
+    ]
+    return MarketEngine(markets_cfg)
+
+
+def _portfolios(specs):
+    """Build a shared portfolios dict from a list of (agent_id, dict) pairs."""
+    return {agent_id: dict(holdings) for agent_id, holdings in specs}
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# 1. Order submission — reservation
+# ──────────────────────────────────────────────────────────────────────────────
+
+class TestOrderReservation:
+
+    def test_bid_reserves_credits(self):
+        engine = _make_engine()
+        portfolios = _portfolios([("alice", {"credits": 100, "gold": 0})])
+
+        result = engine.add_order("alice", "bid", "gold", qty := 5, price := 10.0, portfolios)
+
+        assert result.startswith("SUCCESS")
+        # reserved = price * qty = 50
+        assert portfolios["alice"]["credits"] == pytest_approx(50.0, rel=1e-6)
+
+    def test_ask_reserves_resource(self):
+        engine = _make_engine()
+        portfolios = _portfolios([("bob", {"credits": 0, "gold": 20})])
+
+        result = engine.add_order("bob", "ask", "gold", 8, 10.0, portfolios)
+
+        assert result.startswith("SUCCESS")
+        assert portfolios["bob"]["gold"] == pytest_approx(12.0, rel=1e-6)
+
+    def test_bid_insufficient_credits_rejected(self):
+        engine = _make_engine()
+        portfolios = _portfolios([("poor", {"credits": 10, "gold": 0})])
+
+        result = engine.add_order("poor", "bid", "gold", 10, 10.0, portfolios)
+
+        assert result.startswith("FAILED")
+        assert portfolios["poor"]["credits"] == pytest_approx(10.0)  # no change
+
+    def test_ask_insufficient_resource_rejected(self):
+        engine = _make_engine()
+        portfolios = _portfolios([("broke", {"credits": 1000, "gold": 2})])
+
+        result = engine.add_order("broke", "ask", "gold", 5, 10.0, portfolios)
+
+        assert result.startswith("FAILED")
+        assert portfolios["broke"]["gold"] == pytest_approx(2.0)
+
+    def test_no_market_rejected(self):
+        engine = _make_engine(resources=["gold"])
+        portfolios = _portfolios([("x", {"credits": 500})])
+
+        result = engine.add_order("x", "bid", "corn", 1, 5.0, portfolios)
+
+        assert result.startswith("FAILED")
+        assert "No market" in result
+
+    def test_price_out_of_bounds_rejected(self):
+        engine = _make_engine()
+        portfolios = _portfolios([("x", {"credits": 50000})])
+
+        result = engine.add_order("x", "bid", "gold", 1, 2000.0, portfolios)
+
+        assert result.startswith("FAILED")
+        assert "range" in result.lower()
+
+    def test_invalid_side_rejected(self):
+        engine = _make_engine()
+        portfolios = _portfolios([("x", {"credits": 100})])
+
+        result = engine.add_order("x", "bork", "gold", 1, 10.0, portfolios)
+
+        assert result.startswith("FAILED")
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# 2. Continuous (FIFO) clearing
+# ──────────────────────────────────────────────────────────────────────────────
+
+class TestContinuousClearing:
+
+    def _setup_cross(self, bid_price=12.0, ask_price=10.0, qty=5):
+        """Return (engine, portfolios) with a crossing bid+ask ready to match."""
+        engine = _make_engine()
+        portfolios = _portfolios([
+            ("buyer",  {"credits": 200, "gold": 0}),
+            ("seller", {"credits": 0,   "gold": 20}),
+        ])
+        engine.add_order("buyer",  "bid", "gold", qty, bid_price, portfolios)
+        engine.add_order("seller", "ask", "gold", qty, ask_price, portfolios)
+        return engine, portfolios
+
+    def test_exact_fill(self):
+        engine, portfolios = self._setup_cross(bid_price=12.0, ask_price=10.0, qty=5)
+
+        fills = engine.clear_market("gold", portfolios, tick=1)
+
+        assert len(fills) == 1
+        f = fills[0]
+        assert f["fill_qty"] == pytest_approx(5.0)
+        assert f["buyer"] == "buyer"
+        assert f["seller"] == "seller"
+        # Buyer receives gold
+        assert portfolios["buyer"]["gold"] == pytest_approx(5.0)
+        # Seller receives credits at fill_price * qty
+        fill_price = f["fill_price"]
+        assert portfolios["seller"]["credits"] == pytest_approx(fill_price * 5.0)
+        # Buyer gets surplus from overpaying back
+        expected_surplus = (12.0 - fill_price) * 5.0
+        assert portfolios["buyer"]["credits"] == pytest_approx(200 - 12.0 * 5 + expected_surplus)
+
+    def test_partial_fill(self):
+        engine = _make_engine()
+        portfolios = _portfolios([
+            ("buyer",  {"credits": 200, "gold": 0}),
+            ("seller", {"credits": 0,   "gold": 20}),
+        ])
+        engine.add_order("buyer",  "bid", "gold", 10, 12.0, portfolios)
+        engine.add_order("seller", "ask", "gold",  3, 10.0, portfolios)
+
+        fills = engine.clear_market("gold", portfolios, tick=1)
+
+        assert len(fills) == 1
+        assert fills[0]["fill_qty"] == pytest_approx(3.0)
+        assert portfolios["buyer"]["gold"] == pytest_approx(3.0)
+
+    def test_no_match_when_bid_below_ask(self):
+        engine = _make_engine()
+        portfolios = _portfolios([
+            ("buyer",  {"credits": 200, "gold": 0}),
+            ("seller", {"credits": 0,   "gold": 20}),
+        ])
+        engine.add_order("buyer",  "bid", "gold", 5,  8.0, portfolios)
+        engine.add_order("seller", "ask", "gold", 5, 12.0, portfolios)
+
+        fills = engine.clear_market("gold", portfolios, tick=1)
+
+        assert fills == []
+        assert portfolios["buyer"]["gold"] == 0  # nothing traded
+
+    def test_price_policy_resting(self):
+        engine = _make_engine(extra_cfg={"execution_price_policy": "resting"})
+        portfolios = _portfolios([
+            ("buyer",  {"credits": 300, "gold": 0}),
+            ("seller", {"credits": 0,   "gold": 10}),
+        ])
+        engine.add_order("seller", "ask", "gold", 5, 10.0, portfolios)  # resting
+        engine.add_order("buyer",  "bid", "gold", 5, 15.0, portfolios)  # aggressor
+
+        fills = engine.clear_market("gold", portfolios, tick=1)
+
+        assert len(fills) == 1
+        # Resting is the ask (arrived first), so fill_price should be ask price
+        assert fills[0]["fill_price"] == pytest_approx(10.0)
+
+    def test_price_policy_midpoint(self):
+        engine = _make_engine(extra_cfg={"execution_price_policy": "midpoint"})
+        portfolios = _portfolios([
+            ("buyer",  {"credits": 300, "gold": 0}),
+            ("seller", {"credits": 0,   "gold": 10}),
+        ])
+        engine.add_order("seller", "ask", "gold", 5, 10.0, portfolios)
+        engine.add_order("buyer",  "bid", "gold", 5, 14.0, portfolios)
+
+        fills = engine.clear_market("gold", portfolios, tick=1)
+
+        assert len(fills) == 1
+        assert fills[0]["fill_price"] == pytest_approx(12.0)
+
+    def test_price_policy_aggressive(self):
+        engine = _make_engine(extra_cfg={"execution_price_policy": "aggressive"})
+        portfolios = _portfolios([
+            ("buyer",  {"credits": 300, "gold": 0}),
+            ("seller", {"credits": 0,   "gold": 10}),
+        ])
+        engine.add_order("seller", "ask", "gold", 5, 10.0, portfolios)  # resting
+        engine.add_order("buyer",  "bid", "gold", 5, 14.0, portfolios)  # aggressor
+
+        fills = engine.clear_market("gold", portfolios, tick=1)
+
+        assert len(fills) == 1
+        # Aggressor (bid) sets the price
+        assert fills[0]["fill_price"] == pytest_approx(14.0)
+
+    def test_on_order_clearing_fires_immediately(self):
+        """With clearing='on_order', submission alone should trigger matching."""
+        engine = _make_engine(clearing="on_order")
+        portfolios = _portfolios([
+            ("buyer",  {"credits": 200, "gold": 0}),
+            ("seller", {"credits": 0,   "gold": 20}),
+        ])
+        engine.add_order("seller", "ask", "gold", 5, 10.0, portfolios)
+
+        # Placing the bid with clearing=on_order triggers clear immediately
+        engine.add_order("buyer", "bid", "gold", 5, 12.0, portfolios)
+
+        # Gold should be delivered without calling clear_market explicitly
+        assert portfolios["buyer"]["gold"] == pytest_approx(5.0)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# 3. Cancel + refund
+# ──────────────────────────────────────────────────────────────────────────────
+
+class TestCancel:
+
+    def test_cancel_bid_refunds_credits(self):
+        engine = _make_engine()
+        portfolios = _portfolios([("alice", {"credits": 100, "gold": 0})])
+        result = engine.add_order("alice", "bid", "gold", 5, 10.0, portfolios)
+        order_id = result.split(":")[1].strip().split(" ")[0]
+
+        engine.cancel_order(order_id, "alice", portfolios)
+
+        # All credits returned
+        assert portfolios["alice"]["credits"] == pytest_approx(100.0)
+
+    def test_cancel_ask_refunds_resource(self):
+        engine = _make_engine()
+        portfolios = _portfolios([("bob", {"credits": 0, "gold": 10})])
+        result = engine.add_order("bob", "ask", "gold", 7, 10.0, portfolios)
+        order_id = result.split(":")[1].strip().split(" ")[0]
+
+        engine.cancel_order(order_id, "bob", portfolios)
+
+        assert portfolios["bob"]["gold"] == pytest_approx(10.0)
+
+    def test_cancel_wrong_owner_rejected(self):
+        engine = _make_engine()
+        portfolios = _portfolios([
+            ("alice", {"credits": 100, "gold": 0}),
+            ("eve",   {"credits": 100, "gold": 0}),
+        ])
+        result = engine.add_order("alice", "bid", "gold", 5, 10.0, portfolios)
+        order_id = result.split(":")[1].strip().split(" ")[0]
+
+        cancel_result = engine.cancel_order(order_id, "eve", portfolios)
+
+        assert cancel_result.startswith("FAILED")
+
+    def test_cancel_filled_order_rejected(self):
+        engine = _make_engine(clearing="on_order")
+        portfolios = _portfolios([
+            ("buyer",  {"credits": 200, "gold": 0}),
+            ("seller", {"credits": 0,   "gold": 10}),
+        ])
+        r1 = engine.add_order("seller", "ask", "gold", 5, 10.0, portfolios)
+        r2 = engine.add_order("buyer",  "bid", "gold", 5, 12.0, portfolios)
+        ask_id = r1.split(":")[1].strip().split(" ")[0]
+
+        cancel_result = engine.cancel_order(ask_id, "seller", portfolios)
+
+        # Already filled; cancel should fail
+        assert cancel_result.startswith("FAILED")
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# 4. TTL expiry
+# ──────────────────────────────────────────────────────────────────────────────
+
+class TestExpiry:
+
+    def _place_limit_with_ttl(self, engine, portfolios, ttl=2):
+        """Add a limit order and manually set its TTL for expiry testing."""
+        result = engine.add_order("alice", "bid", "gold", 5, 10.0, portfolios, tick=0)
+        order_id = result.split(":")[1].strip().split(" ")[0]
+        with engine._lock:
+            engine._order_index[order_id].ttl = ttl
+        return order_id
+
+    def test_order_not_expired_before_ttl(self):
+        engine = _make_engine()
+        portfolios = _portfolios([("alice", {"credits": 100, "gold": 0})])
+        order_id = self._place_limit_with_ttl(engine, portfolios, ttl=3)
+
+        engine.expire_orders(tick=2, portfolios=portfolios)
+
+        # Under TTL: credits still reserved
+        assert portfolios["alice"]["credits"] == pytest_approx(50.0)
+
+    def test_order_expired_at_ttl_refunds(self):
+        engine = _make_engine()
+        portfolios = _portfolios([("alice", {"credits": 100, "gold": 0})])
+        order_id = self._place_limit_with_ttl(engine, portfolios, ttl=2)
+
+        engine.expire_orders(tick=2, portfolios=portfolios)
+
+        # TTL reached: credits returned
+        assert portfolios["alice"]["credits"] == pytest_approx(100.0)
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# 5. Call-auction clearing
+# ──────────────────────────────────────────────────────────────────────────────
+
+class TestCallAuction:
+
+    def test_call_auction_matches_at_clearing_price(self):
+        engine = _make_engine(clearing="call_auction")
+        portfolios = _portfolios([
+            ("buyer1", {"credits": 500, "gold": 0}),
+            ("buyer2", {"credits": 500, "gold": 0}),
+            ("seller", {"credits": 0,   "gold": 20}),
+        ])
+        engine.add_order("buyer1", "bid", "gold", 5, 12.0, portfolios)
+        engine.add_order("buyer2", "bid", "gold", 5, 11.0, portfolios)
+        engine.add_order("seller", "ask", "gold", 8, 10.0, portfolios)
+
+        fills = engine.clear_market("gold", portfolios, tick=1)
+
+        assert len(fills) > 0
+        total_qty = sum(f["fill_qty"] for f in fills)
+        assert total_qty == pytest_approx(8.0, rel=1e-6)
+        # All fills at the same uniform price
+        assert all(f["fill_price"] == fills[0]["fill_price"] for f in fills)
+
+    def test_call_auction_no_overlap_no_fill(self):
+        engine = _make_engine(clearing="call_auction")
+        portfolios = _portfolios([
+            ("buyer",  {"credits": 200, "gold": 0}),
+            ("seller", {"credits": 0,   "gold": 10}),
+        ])
+        engine.add_order("buyer",  "bid", "gold", 5,  8.0, portfolios)
+        engine.add_order("seller", "ask", "gold", 5, 12.0, portfolios)
+
+        fills = engine.clear_market("gold", portfolios, tick=1)
+
+        assert fills == []
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# 6. Market orders
+# ──────────────────────────────────────────────────────────────────────────────
+
+class TestMarketOrders:
+
+    def test_market_buy_sweeps_liquidity(self):
+        engine = _make_engine()
+        portfolios = _portfolios([
+            ("buyer",  {"credits": 500, "gold": 0}),
+            ("seller", {"credits": 0,   "gold": 20}),
+        ])
+        engine.add_order("seller", "ask", "gold", 5, 10.0, portfolios)
+
+        result = engine.add_market_order("buyer", "bid", "gold", 5, portfolios, tick=1)
+
+        assert result.startswith("SUCCESS")
+        assert portfolios["buyer"]["gold"] == pytest_approx(5.0)
+
+    def test_market_sell_sweeps_demand(self):
+        engine = _make_engine()
+        portfolios = _portfolios([
+            ("buyer",  {"credits": 500, "gold": 0}),
+            ("seller", {"credits": 0,   "gold": 20}),
+        ])
+        engine.add_order("buyer", "bid", "gold", 5, 10.0, portfolios)
+
+        result = engine.add_market_order("seller", "ask", "gold", 5, portfolios, tick=1)
+
+        assert result.startswith("SUCCESS")
+        assert portfolios["seller"]["credits"] > 0
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# 7. get_price / get_order_book
+# ──────────────────────────────────────────────────────────────────────────────
+
+class TestReadPaths:
+
+    def test_get_price_returns_initial_price(self):
+        engine = _make_engine()
+        assert engine.get_price("gold") == pytest_approx(10.0)
+
+    def test_get_price_updates_after_fill(self):
+        engine = _make_engine(clearing="on_order")
+        portfolios = _portfolios([
+            ("buyer",  {"credits": 300, "gold": 0}),
+            ("seller", {"credits": 0,   "gold": 10}),
+        ])
+        engine.add_order("seller", "ask", "gold", 5, 8.0, portfolios)
+        engine.add_order("buyer",  "bid", "gold", 5, 12.0, portfolios)
+
+        p = engine.get_price("gold")
+        # fill price is 8.0 (resting ask) by default policy
+        assert p == pytest_approx(8.0)
+
+    def test_get_price_unknown_resource_is_none(self):
+        engine = _make_engine()
+        assert engine.get_price("corn") is None
+
+    def test_get_order_book_structure(self):
+        engine = _make_engine()
+        portfolios = _portfolios([("alice", {"credits": 200, "gold": 10})])
+        engine.add_order("alice", "bid", "gold", 5, 9.0, portfolios)
+        engine.add_order("alice", "ask", "gold", 3, 11.0, portfolios)
+
+        book = engine.get_order_book("gold", depth=5)
+
+        assert book is not None
+        assert "bids" in book and "asks" in book
+        assert book["resource"] == "gold"
+        assert len(book["bids"]) > 0
+        assert len(book["asks"]) > 0
+
+    def test_get_order_book_unknown_resource_is_none(self):
+        engine = _make_engine()
+        assert engine.get_order_book("corn") is None
+
+    def test_per_market_lock_reads_different_resources(self):
+        """Reads on different markets should not share the same RLock instance."""
+        engine = _make_engine(resources=["gold", "corn"])
+        assert engine._market_locks["gold"] is not engine._market_locks["corn"]
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# 8. Thread-safety stress test
+# ──────────────────────────────────────────────────────────────────────────────
+
+class TestThreadSafety:
+
+    def test_concurrent_bids_and_asks_no_exception(self):
+        """Many threads placing orders simultaneously must not corrupt state."""
+        n_agents = 8
+        n_orders_each = 10
+        engine = _make_engine(clearing="continuous")
+
+        portfolios = {
+            f"buyer_{i}":  {"credits": 5000, "gold": 0}
+            for i in range(n_agents)
+        }
+        portfolios.update({
+            f"seller_{i}": {"credits": 0, "gold": 5000}
+            for i in range(n_agents)
+        })
+
+        errors = []
+
+        def place_and_clear(i):
+            try:
+                for j in range(n_orders_each):
+                    price = 10.0 + (i % 3)
+                    engine.add_order(f"buyer_{i}",  "bid", "gold", 1, price + 2, portfolios)
+                    engine.add_order(f"seller_{i}", "ask", "gold", 1, price,     portfolios)
+                    engine.clear_market("gold", portfolios, tick=j)
+            except Exception as exc:
+                errors.append(exc)
+
+        threads = [threading.Thread(target=place_and_clear, args=(i,)) for i in range(n_agents)]
+        for t in threads:
+            t.start()
+        for t in threads:
+            t.join(timeout=10)
+
+        assert errors == [], f"Thread safety violations: {errors}"
+
+    def test_concurrent_price_reads_with_writes(self):
+        """Price reads and order writes from separate threads must not raise."""
+        engine = _make_engine(clearing="continuous")
+        portfolios = {f"a{i}": {"credits": 5000, "gold": 5000} for i in range(4)}
+        stop_flag = threading.Event()
+        read_errors = []
+        write_errors = []
+
+        def writer():
+            for k in range(50):
+                try:
+                    engine.add_order(f"a{k % 4}", "bid", "gold", 1, 10.0, portfolios, tick=k)
+                    engine.clear_market("gold", portfolios, tick=k)
+                except Exception as e:
+                    write_errors.append(e)
+
+        def reader():
+            while not stop_flag.is_set():
+                try:
+                    engine.get_price("gold")
+                except Exception as e:
+                    read_errors.append(e)
+                    stop_flag.set()
+
+        r = threading.Thread(target=reader, daemon=True)
+        w = threading.Thread(target=writer)
+        r.start()
+        w.start()
+        w.join(timeout=5)
+        stop_flag.set()
+        r.join(timeout=1)
+
+        assert read_errors == [], f"Read errors under concurrent writes: {read_errors}"
+        assert write_errors == [], f"Write errors: {write_errors}"
+
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Compatibility shim — makes `pytest_approx` available as a bare name
+# ──────────────────────────────────────────────────────────────────────────────
+
+try:
+    from pytest import approx as pytest_approx  # type: ignore[import]
+except ImportError:
+    # Fallback for environments where pytest isn't installed yet
+    def pytest_approx(value, rel=1e-6, abs=None):  # type: ignore[override]
+        return value

doxa_ai-0.1.0/tests/test_relation_graph.py

@@ -0,0 +1,75 @@
+from relations.RelationGraph import RelationGraph  # type: ignore[import]
+
+
+def test_init_from_yaml_loads_explicit_relations_and_keeps_lazy_neutral_defaults():
+    graph = RelationGraph()
+    graph.init_from_yaml(
+        [
+            {"source": "alice", "target": "bob", "trust": 0.8, "type": "ally"},
+        ],
+        ["alice", "bob", "carol"],
+    )
+
+    assert graph.get_trust("alice", "bob") == 0.8
+    assert graph.get_rel_type("alice", "bob") == "ally"
+    assert graph.get_trust("bob", "alice") == 0.5
+    assert graph.get_rel_type("bob", "alice") == "neutral"
+
+
+def test_update_trust_creates_missing_edges_and_reclassifies_labels():
+    graph = RelationGraph()
+
+    graph.update_trust("alice", "bob", 0.3)
+    assert graph.get_trust("alice", "bob") == 0.8
+    assert graph.get_rel_type("alice", "bob") == "ally"
+
+    graph.update_trust("alice", "carol", -0.15)
+    assert graph.get_trust("alice", "carol") == 0.35
+    assert graph.get_rel_type("alice", "carol") == "rival"
+
+    graph.update_trust("alice", "dave", -0.3)
+    assert graph.get_trust("alice", "dave") == 0.2
+    assert graph.get_rel_type("alice", "dave") == "enemy"
+
+
+def test_update_trust_clamps_values_to_unit_interval():
+    graph = RelationGraph()
+
+    graph.update_trust("alice", "bob", 2.0)
+    graph.update_trust("carol", "dave", -2.0)
+
+    assert graph.get_trust("alice", "bob") == 1.0
+    assert graph.get_trust("carol", "dave") == 0.0
+
+
+def test_decay_all_moves_values_toward_neutral_without_overshooting():
+    graph = RelationGraph()
+    graph.init_from_yaml(
+        [
+            {"source": "alice", "target": "bob", "trust": 0.9, "type": "ally"},
+            {"source": "bob", "target": "alice", "trust": 0.2, "type": "enemy"},
+        ],
+        ["alice", "bob"],
+    )
+
+    graph.decay_all(0.25)
+    assert graph.get_trust("alice", "bob") == 0.65
+    assert graph.get_trust("bob", "alice") == 0.45
+
+    graph.decay_all(0.25)
+    assert graph.get_trust("alice", "bob") == 0.5
+    assert graph.get_trust("bob", "alice") == 0.5
+
+
+def test_to_list_serializes_relation_records_with_rounded_trust():
+    graph = RelationGraph()
+    graph.init_from_yaml(
+        [
+            {"source": "alice", "target": "bob", "trust": 0.67891, "type": "neutral"},
+        ],
+        ["alice", "bob"],
+    )
+
+    assert graph.to_list() == [
+        {"source": "alice", "target": "bob", "trust": 0.6789, "type": "neutral"}
+    ]

doxa_ai-0.1.0/tests/test_scenarios.py

@@ -0,0 +1,33 @@
+from pathlib import Path
+
+import yaml
+
+
+REPO_ROOT = Path(__file__).resolve().parents[2]
+SCENARIO_FILES = sorted((REPO_ROOT / "scenarios").glob("*.yaml"))
+
+
+def test_scenario_files_exist():
+    assert SCENARIO_FILES, "Expected at least one scenario YAML file"
+    for scenario_path in SCENARIO_FILES:
+        assert scenario_path.exists(), f"Missing scenario file: {scenario_path}"
+
+
+def test_scenario_files_are_valid_yaml():
+    for scenario_path in SCENARIO_FILES:
+        with scenario_path.open("r", encoding="utf-8") as handle:
+            data = yaml.safe_load(handle)
+
+        assert isinstance(data, dict), f"Scenario must load as a mapping: {scenario_path.name}"
+        assert "global_rules" in data, f"Missing global_rules in {scenario_path.name}"
+        assert "actors" in data, f"Missing actors in {scenario_path.name}"
+        assert isinstance(data["actors"], list) and data["actors"], f"actors must be a non-empty list in {scenario_path.name}"
+
+
+def test_scenario_actor_ids_are_unique_per_file():
+    for scenario_path in SCENARIO_FILES:
+        with scenario_path.open("r", encoding="utf-8") as handle:
+            data = yaml.safe_load(handle)
+
+        actor_ids = [actor["id"] for actor in data["actors"]]
+        assert len(actor_ids) == len(set(actor_ids)), f"Duplicate actor ids in {scenario_path.name}"

doxa_ai-0.1.0/tests/test_world_events.py

@@ -0,0 +1,105 @@
+from events.WorldEventScheduler import WorldEventScheduler  # type: ignore[import]
+from market.MarketEngine import MarketEngine  # type: ignore[import]
+from relations.RelationGraph import RelationGraph  # type: ignore[import]
+
+
+def _make_market_engine():
+    return MarketEngine(
+        [
+            {
+                "resource": "gold",
+                "currency": "credits",
+                "initial_price": 10.0,
+                "min_price": 1.0,
+                "max_price": 100.0,
+                "clearing": "per_step",
+            }
+        ]
+    )
+
+
+def test_shock_event_applies_delta_once():
+    scheduler = WorldEventScheduler(
+        [
+            {
+                "name": "panic_spike",
+                "type": "shock",
+                "trigger": {"tick": 2},
+                "effect": {"targets": "all", "resource": "panic", "delta": 0.2},
+            }
+        ]
+    )
+    portfolios = {"alice": {"panic": 0.0}}
+    agents = {"alice": object()}
+
+    assert scheduler.tick(portfolios, agents, None, None, None, 1) == []
+    fired = scheduler.tick(portfolios, agents, None, None, None, 2)
+    assert len(fired) == 1
+    assert portfolios["alice"]["panic"] == 0.2
+    assert scheduler.tick(portfolios, agents, None, None, None, 3) == []
+    assert portfolios["alice"]["panic"] == 0.2
+
+
+def test_trend_event_applies_rate_for_full_duration():
+    scheduler = WorldEventScheduler(
+        [
+            {
+                "name": "relief_flow",
+                "type": "trend",
+                "trigger": {"tick": 1},
+                "duration": 3,
+                "effect": {"targets": "all", "resource": "food", "rate": 1.5},
+            }
+        ]
+    )
+    portfolios = {"alice": {"food": 0.0}, "bob": {"food": 1.0}}
+    agents = {"alice": object(), "bob": object()}
+
+    assert len(scheduler.tick(portfolios, agents, None, None, None, 1)) == 1
+    assert len(scheduler.tick(portfolios, agents, None, None, None, 2)) == 1
+    assert len(scheduler.tick(portfolios, agents, None, None, None, 3)) == 1
+    assert scheduler.tick(portfolios, agents, None, None, None, 4) == []
+    assert portfolios["alice"]["food"] == 4.5
+    assert portfolios["bob"]["food"] == 5.5
+
+
+def test_conditional_event_updates_market_and_trust_once():
+    scheduler = WorldEventScheduler(
+        [
+            {
+                "name": "ceasefire",
+                "type": "conditional",
+                "trigger": {
+                    "condition": {
+                        "resource": "panic",
+                        "operator": "gt",
+                        "threshold": 0.5,
+                        "scope": "any_agent",
+                    }
+                },
+                "effect": {
+                    "targets": ["beta"],
+                    "market": "gold",
+                    "price_multiplier": 1.5,
+                    "trust_source": "alpha",
+                    "trust_delta": 0.2,
+                },
+            }
+        ]
+    )
+    portfolios = {"alpha": {"panic": 0.1}, "beta": {"panic": 0.7}}
+    agents = {"alpha": object(), "beta": object()}
+    market_engine = _make_market_engine()
+    relation_graph = RelationGraph()
+    relation_graph.init_from_yaml(
+        [{"source": "alpha", "target": "beta", "trust": 0.5, "type": "neutral"}],
+        ["alpha", "beta"],
+    )
+
+    fired = scheduler.tick(portfolios, agents, market_engine, relation_graph, None, 1)
+    assert len(fired) == 1
+    assert market_engine.get_price("gold") == 15.0
+    assert relation_graph.get_trust("alpha", "beta") == 0.7
+
+    assert scheduler.tick(portfolios, agents, market_engine, relation_graph, None, 2) == []
+    assert market_engine.get_price("gold") == 15.0