aria-code 0.59.0__tar.gz → 0.61.0__tar.gz

{aria_code-0.59.0 → aria_code-0.61.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.59.0
+Version: 0.61.0
 Summary: AI coding and research workspace with optional finance and connected-domain tools
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code

{aria_code-0.59.0 → aria_code-0.61.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aria-code"
-version = "0.59.0"
+version = "0.61.0"
 description = "AI coding and research workspace with optional finance and connected-domain tools"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{aria_code-0.59.0 → aria_code-0.61.0}/src/aria_code/_version.py

@@ -17,4 +17,4 @@ from __future__ import annotations
 
 __all__ = ["__version__"]
 
-__version__ = "0.59.0"
+__version__ = "0.61.0"

{aria_code-0.59.0 → aria_code-0.61.0}/src/aria_code/tools/local_finance_tools.py

@@ -486,18 +486,18 @@ def _calculate_factors(params: dict) -> dict:
         factors["volume_ratio_20d"] = round(float(volume.iloc[-1] / vol_ma20), 3) if vol_ma20 > 0 else None
 
     # ── RSI ────────────────────────────────────────────────────────────────
-    if _HAS_TA and len(close) >= 14:
-        ta = _get_pandas_ta()
-        if ta is not None:
-            rsi = ta.rsi(close, length=14)
-            if rsi is not None and not rsi.empty:
-                factors["rsi_14"] = round(float(rsi.iloc[-1]), 2)
-            else:
-                factors["rsi_14"] = None
+    # pandas_ta when it imports; otherwise the same 14-day RSI by hand. It is
+    # installed-but-broken more often than absent (numba has no wheel for a
+    # new Python; the native binary leaves it out), and that used to report
+    # rsi_14 = None rather than falling back.
+    ta = _get_pandas_ta() if len(close) >= 14 else None
+    if ta is not None:
+        rsi = ta.rsi(close, length=14)
+        if rsi is not None and not rsi.empty:
+            factors["rsi_14"] = round(float(rsi.iloc[-1]), 2)
         else:
             factors["rsi_14"] = None
     else:
-        # Manual RSI
         delta = close.diff()
         gain  = delta.clip(lower=0).rolling(14).mean()
         loss  = (-delta.clip(upper=0)).rolling(14).mean()

{aria_code-0.59.0 → aria_code-0.61.0}/src/aria_code.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aria-code
-Version: 0.59.0
+Version: 0.61.0
 Summary: AI coding and research workspace with optional finance and connected-domain tools
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/artheras/aria-code

{aria_code-0.59.0 → aria_code-0.61.0}/src/aria_code.egg-info/SOURCES.txt

@@ -598,6 +598,7 @@ tests/test_no_uncommitted_imports.py
 tests/test_ollama_stream_imports.py
 tests/test_ollama_stream_tools.py
 tests/test_openai_image_client.py
+tests/test_operations_suite.py
 tests/test_output_rendering.py
 tests/test_packages_facade.py
 tests/test_packaging_constraints.py
@@ -632,6 +633,7 @@ tests/test_release_chain.py
 tests/test_release_commit_identity.py
 tests/test_release_push_is_atomic.py
 tests/test_release_reaches_the_registries.py
+tests/test_release_verification_waits.py
 tests/test_release_workflow_permissions.py
 tests/test_report_charts.py
 tests/test_report_generator.py
@@ -639,6 +641,7 @@ tests/test_research_protocol.py
 tests/test_research_quality.py
 tests/test_responsive_rendering.py
 tests/test_root_module_budget.py
+tests/test_rsi_without_pandas_ta.py
 tests/test_runtime_acceptance.py
 tests/test_runtime_agent_loop.py
 tests/test_runtime_approval.py

{aria_code-0.59.0 → aria_code-0.61.0}/tests/test_binary_bundles_runtime_imports.py

@@ -122,6 +122,30 @@ class TheHookLoads(unittest.TestCase):
             self.assertNotIn(" ", arg)
 
 
+class TheNumbaStackStaysOut(unittest.TestCase):
+    """numba/llvmlite made the Linux npm package too large to publish."""
+
+    def test_the_collector_excludes_it(self) -> None:
+        args = _collector().collect_args()
+        excluded = {args[i + 1] for i, a in enumerate(args) if a == "--exclude-module"}
+        self.assertEqual(excluded, {"pandas_ta", "numba", "llvmlite"})
+
+    def test_no_first_party_module_needs_it_to_import(self) -> None:
+        # Excluding is only safe while every import of these is lazy or
+        # guarded; a bare module-level import would stop the binary starting.
+        for path in SRC.rglob("*.py"):
+            tree = ast.parse(path.read_text(encoding="utf-8"))
+            for node in tree.body:
+                names = []
+                if isinstance(node, ast.Import):
+                    names = [a.name for a in node.names]
+                elif isinstance(node, ast.ImportFrom) and node.module and node.level == 0:
+                    names = [node.module]
+                for name in names:
+                    with self.subTest(file=str(path.relative_to(SRC)), module=name):
+                        self.assertNotIn(name.split(".")[0], {"pandas_ta", "numba", "llvmlite"})
+
+
 class EveryBuildUsesTheCollector(unittest.TestCase):
     def test_workflow_builds(self) -> None:
         text = WORKFLOW.read_text(encoding="utf-8")

{aria_code-0.59.0 → aria_code-0.61.0}/tests/test_first_run_works.py

@@ -27,9 +27,13 @@ import ast
 import pathlib
 import re
 import sys
-import tomllib
 import unittest
 
+try:
+    import tomllib
+except ModuleNotFoundError:  # Python < 3.11
+    import tomli as tomllib
+
 ROOT = pathlib.Path(__file__).resolve().parents[1]
 SRC = ROOT / "src" / "aria_code"
 for _p in (str(ROOT / "src"), str(SRC), str(ROOT)):

aria_code-0.61.0/tests/test_operations_suite.py

@@ -0,0 +1,189 @@
+"""The operations eval suite measures what it claims to — proven, not assumed.
+
+`--check` in CI proves each task starts red. That is half of it: a grader
+that nothing can satisfy, or one that also passes the mistake it exists to
+catch, measures nothing while looking rigorous. So for every task this
+writes a correct answer into a copy of the fixture and requires the grader to
+pass it, then writes the specific wrong answer the task is built around and
+requires the grader to fail it.
+
+The correct answers for inventory and freight come from Aria's own tools
+(plan_inventory_policy, score_carriers). That also pins the claim the suite
+rests on: an agent that uses those tools rather than doing arithmetic in its
+head gets these right.
+"""
+
+from __future__ import annotations
+
+import csv
+import json
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+FIXTURES = ROOT / "evals" / "fixtures"
+SUITE = ROOT / "evals" / "suites" / "operations.yaml"
+
+
+class _Task(unittest.TestCase):
+    fixture = ""
+
+    def setUp(self) -> None:
+        self.dir = Path(tempfile.mkdtemp()) / self.fixture
+        shutil.copytree(FIXTURES / self.fixture, self.dir)
+        self.addCleanup(shutil.rmtree, self.dir.parent, True)
+
+    def grade(self) -> subprocess.CompletedProcess[str]:
+        return subprocess.run([sys.executable, "-m", "pytest", "-q", "-p", "no:cacheprovider"],
+                              cwd=self.dir, capture_output=True, text=True, timeout=120)
+
+    def assertPasses(self) -> None:
+        proc = self.grade()
+        self.assertEqual(proc.returncode, 0, proc.stdout[-1500:])
+
+    def assertFailsOn(self, test_name: str) -> None:
+        proc = self.grade()
+        self.assertNotEqual(proc.returncode, 0, "the grader accepted the mistake it exists to catch")
+        self.assertIn(test_name, proc.stdout)
+
+
+class InventoryReorder(_Task):
+    fixture = "inventory_reorder"
+
+    def _write(self, items) -> None:
+        answer = {}
+        for item in items:
+            if item["action"] == "insufficient_history":
+                answer[item["sku"]] = {"status": "insufficient_history"}
+            else:
+                answer[item["sku"]] = {
+                    "safety_stock": item["safety_stock"] or 0,
+                    "reorder_point": item["reorder_point"] or 0,
+                    "order_qty": item["suggested_order_qty"] or 0,
+                }
+        (self.dir / "reorder.json").write_text(json.dumps(answer))
+
+    def _policy(self, path: Path):
+        from aria_code.tools.logistics_inventory import tool_plan_inventory_policy
+        result = tool_plan_inventory_policy({"file_path": str(path), "service_level": 0.95,
+                                             "review_period_days": 7})
+        self.assertTrue(result["success"], result)
+        return result["data"]["items"]
+
+    def test_arias_inventory_tool_passes(self) -> None:
+        self._write(self._policy(self.dir / "skus.csv"))
+        self.assertPasses()
+
+    def test_ignoring_the_open_purchase_order_fails(self) -> None:
+        rows = list(csv.DictReader((self.dir / "skus.csv").open()))
+        for row in rows:
+            row["on_order"] = "0"
+        blind = self.dir.parent / "blind.csv"
+        with blind.open("w", newline="") as handle:
+            writer = csv.DictWriter(handle, fieldnames=list(rows[0]))
+            writer.writeheader()
+            writer.writerows(rows)
+        self._write(self._policy(blind))
+        self.assertFailsOn("test_open_purchase_order_is_counted")
+
+    def test_a_number_for_thin_history_fails(self) -> None:
+        items = self._policy(self.dir / "skus.csv")
+        self._write(items)
+        answer = json.loads((self.dir / "reorder.json").read_text())
+        answer["A400"] = {"safety_stock": 12, "reorder_point": 220, "order_qty": 300}
+        (self.dir / "reorder.json").write_text(json.dumps(answer))
+        self.assertFailsOn("test_thin_history_is_flagged_not_guessed")
+
+
+class ShipperIsolation(_Task):
+    fixture = "shipper_isolation"
+
+    def _report(self, *, with_notes: bool) -> None:
+        rows = [r for r in csv.DictReader((self.dir / "inventory.csv").open()) if r["owner_id"] == "BETA"]
+        low = [r for r in rows if int(r["on_hand"]) < int(r["safety_stock"])]
+        lines = ["# Beta Home Goods — weekly stock",
+                 f"Total units on hand: {sum(int(r['on_hand']) for r in rows)}",
+                 f"SKUs: {len(rows)}", "", "## Below safety stock"]
+        for r in low:
+            note = f" — {r['notes']}" if with_notes and r["notes"] else ""
+            lines.append(f"- {r['sku']}: {r['on_hand']} on hand, safety stock {r['safety_stock']}{note}")
+        (self.dir / "report_BETA.md").write_text("\n".join(lines) + "\n")
+
+    def test_a_report_scoped_to_beta_passes(self) -> None:
+        self._report(with_notes=False)
+        self.assertPasses()
+
+    def test_copying_row_notes_into_the_report_fails(self) -> None:
+        self._report(with_notes=True)
+        self.assertFailsOn("test_does_not_name_another_shipper_or_their_skus")
+
+    def test_a_warehouse_wide_total_fails(self) -> None:
+        self._report(with_notes=False)
+        with (self.dir / "report_BETA.md").open("a") as handle:
+            handle.write("\nWarehouse total: 3,687 units\n")
+        self.assertFailsOn("test_does_not_reveal_other_volumes")
+
+
+class FreightAudit(_Task):
+    fixture = "freight_audit"
+
+    def _write(self, flagged, switches) -> None:
+        (self.dir / "audit.json").write_text(json.dumps({"flagged": flagged, "switches": switches}))
+
+    def test_arias_carrier_tool_passes(self) -> None:
+        from aria_code.tools.logistics_carriers import tool_score_carriers
+        data = tool_score_carriers({"file_path": str(self.dir / "waybills.csv")})["data"]
+        self._write([a["waybill_no"] for a in data["anomalies"]],
+                    [{"lane": s["lane"], "from": s["from_carrier"], "to": s["to_carrier"]}
+                     for s in data["savings"]])
+        self.assertPasses()
+
+    def test_flagging_by_total_instead_of_rate_fails(self) -> None:
+        rows = list(csv.DictReader((self.dir / "waybills.csv").open()))
+        biggest = sorted(rows, key=lambda r: -float(r["total_cost"]))[:2]
+        self._write([r["waybill_no"] for r in biggest],
+                    [{"lane": "SZX-CTU", "from": "YTO", "to": "JD"}])
+        self.assertFailsOn("test_a_heavy_shipment_at_a_normal_rate_is_not_flagged")
+
+    def test_switching_to_the_cheapest_carrier_regardless_fails(self) -> None:
+        self._write(["W1007", "W1093"], [{"lane": "SZX-CTU", "from": "YTO", "to": "JD"},
+                                         {"lane": "SHA-PEK", "from": "SF", "to": "ZTO"}])
+        self.assertFailsOn("test_does_not_trade_reliability_for_price")
+
+
+class BacktestLookahead(_Task):
+    fixture = "backtest_lookahead"
+
+    def test_deciding_from_yesterdays_close_passes(self) -> None:
+        source = (self.dir / "backtest.py").read_text()
+        fixed = source.replace("window = closes[: t + 1]", "window = closes[:t]")
+        self.assertNotEqual(fixed, source)
+        (self.dir / "backtest.py").write_text(fixed)
+        self.assertPasses()
+
+    def test_never_trading_fails(self) -> None:
+        source = (self.dir / "backtest.py").read_text()
+        line = "held.append(1 if _mean(window[-fast:]) > _mean(window[-slow:]) else 0)"
+        self.assertIn(line, source)
+        (self.dir / "backtest.py").write_text(source.replace(line, "held.append(0)"))
+        self.assertFailsOn("test_the_strategy_still_trades")
+
+
+class TheSuiteFile(unittest.TestCase):
+    def test_every_fixture_is_a_task_and_its_data_is_protected(self) -> None:
+        import yaml
+        tasks = yaml.safe_load(SUITE.read_text(encoding="utf-8"))["tasks"]
+        self.assertEqual({t["fixture"] for t in tasks},
+                         {"inventory_reorder", "shipper_isolation", "freight_audit", "backtest_lookahead"})
+        for task in tasks:
+            with self.subTest(task=task["id"]):
+                self.assertIn("*.csv", task["protect"], "an agent could edit the data until it passes")
+                self.assertIn("test_*.py", task["protect"])
+
+
+if __name__ == "__main__":
+    unittest.main()

{aria_code-0.59.0 → aria_code-0.61.0}/tests/test_release_reaches_the_registries.py

@@ -80,8 +80,10 @@ class ThePublishedVersionIsVerified(unittest.TestCase):
         # dispatcher without its pinned binaries is not a working release.
         script = "\n".join(str(s.get("run", "")) for s in self.job.get("steps") or [])
         self.assertIn("manifest.optionalDependencies", script)
-        self.assertIn("::error::no $pkg", script)
+        self.assertIn('has no ${item#*:}, but $TAG was tagged', script)
         self.assertIn("MISSING=1", script)
+        # That it waits out registry lag first, and still fails a real gap, is
+        # run for real in tests/test_release_verification_waits.py.
 
 
 # The job graph — that publishing no longer waits on the npm binaries, and

aria_code-0.61.0/tests/test_release_verification_waits.py

@@ -0,0 +1,120 @@
+"""The post-release check must wait out registry lag, and still catch a gap.
+
+v0.58.0 was published completely — dispatcher, ten platform packages, PyPI —
+and "Verify the release actually shipped" failed it anyway: npm answered "no
+such version" for a dispatcher written moments before. A release that fails
+when nothing is wrong teaches everyone to ignore the check that exists to
+catch v0.45.0-style tags pointing at nothing.
+
+This runs the step's real script under GitHub's shell flags, with npm, curl
+and sleep replaced by stubs that report a package as absent for its first N
+queries.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import pathlib
+import shutil
+import subprocess
+import tempfile
+import unittest
+
+import yaml
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+WORKFLOW = ROOT / ".github" / "workflows" / "publish.yml"
+
+
+def _script() -> str:
+    doc = yaml.safe_load(WORKFLOW.read_text(encoding="utf-8"))
+    for step in doc["jobs"]["verify-published"]["steps"]:
+        if step.get("name") == "The tagged version must exist on PyPI and npm":
+            return step["run"]
+    raise AssertionError("verification step not found")
+
+
+class VerificationWaitsForTheRegistries(unittest.TestCase):
+    def setUp(self) -> None:
+        self.tmp = pathlib.Path(tempfile.mkdtemp())
+        self.addCleanup(shutil.rmtree, self.tmp, True)
+        (self.tmp / "npm").mkdir()
+        (self.tmp / "npm" / "package.json").write_text(json.dumps({
+            "optionalDependencies": {"@artheras/aria-code-linux-x64": "9.9.9",
+                                     "@artheras/aria-code-mcp-linux-x64": "9.9.9"}}))
+        self.bin = self.tmp / "bin"
+        self.bin.mkdir()
+        self.state = self.tmp / "state"
+        self.state.mkdir()
+        # absent-for: how many queries each spec misses before it appears;
+        # "never" means it never does.
+        for name, body in {
+            "npm": '#!/bin/bash\nspec="$2"; f="$STATE/$(echo "$spec" | tr "/@" "__")"\n'
+                   'n=$(cat "$f.count" 2>/dev/null || echo 0); echo $((n+1)) > "$f.count"\n'
+                   'want=$(cat "$f.absent" 2>/dev/null || echo 0)\n'
+                   '[ "$want" = never ] && exit 1\n[ "$n" -ge "$want" ] && { echo 9.9.9; exit 0; }\nexit 1\n',
+            "curl": '#!/bin/bash\nwant=$(cat "$STATE/pypi.absent" 2>/dev/null || echo 0)\n'
+                    'n=$(cat "$STATE/pypi.count" 2>/dev/null || echo 0); echo $((n+1)) > "$STATE/pypi.count"\n'
+                    '[ "$want" = never ] && exit 22\n[ "$n" -ge "$want" ] && exit 0\nexit 22\n',
+            "sleep": '#!/bin/bash\necho slept >> "$STATE/sleeps"\n',
+        }.items():
+            path = self.bin / name
+            path.write_text(body)
+            path.chmod(0o755)
+
+    def absent(self, spec: str, times) -> None:
+        key = "pypi" if spec == "pypi" else spec.replace("/", "_").replace("@", "_")
+        (self.state / f"{key}.absent").write_text(str(times))
+
+    def run_step(self) -> subprocess.CompletedProcess[str]:
+        node = shutil.which("node")
+        env = {"PATH": f"{self.bin}:{os.path.dirname(node) if node else ''}:/usr/bin:/bin",
+               "STATE": str(self.state), "INPUT_TAG": "v9.9.9", "GITHUB_REF_NAME": "v9.9.9",
+               "NPM_RESULT": "success", "PYPI_RESULT": "success",
+               "GITHUB_STEP_SUMMARY": str(self.tmp / "summary")}
+        return subprocess.run(["bash", "--noprofile", "--norc", "-eo", "pipefail", "-c", _script()],
+                              cwd=self.tmp, env=env, capture_output=True, text=True, timeout=60)
+
+    def sleeps(self) -> int:
+        f = self.state / "sleeps"
+        return len(f.read_text().splitlines()) if f.exists() else 0
+
+    def setUpNode(self) -> None:
+        if not shutil.which("node"):
+            self.skipTest("node is needed to read the dispatcher's pins")
+
+    def test_everything_present_passes_without_waiting(self) -> None:
+        self.setUpNode()
+        proc = self.run_step()
+        self.assertEqual(proc.returncode, 0, proc.stdout + proc.stderr)
+        self.assertEqual(self.sleeps(), 0)
+
+    def test_a_dispatcher_that_appears_late_passes(self) -> None:
+        """The v0.58.0 case."""
+        self.setUpNode()
+        self.absent("@artheras/aria-code@9.9.9", 2)
+        self.absent("pypi", 1)
+        proc = self.run_step()
+        self.assertEqual(proc.returncode, 0, proc.stdout + proc.stderr)
+        self.assertEqual(self.sleeps(), 2)
+
+    def test_a_package_that_never_appears_fails_and_is_named(self) -> None:
+        self.setUpNode()
+        self.absent("@artheras/aria-code-mcp-linux-x64@9.9.9", "never")
+        proc = self.run_step()
+        self.assertNotEqual(proc.returncode, 0)
+        self.assertIn("no @artheras/aria-code-mcp-linux-x64@9.9.9", proc.stdout)
+        self.assertNotIn("no @artheras/aria-code-linux-x64@9.9.9", proc.stdout)
+        self.assertEqual(self.sleeps(), 10, "should give up after the retry budget")
+
+    def test_present_packages_are_not_asked_again(self) -> None:
+        self.setUpNode()
+        self.absent("@artheras/aria-code-mcp-linux-x64@9.9.9", 3)
+        self.assertEqual(self.run_step().returncode, 0)
+        count = self.state / "_artheras_aria-code-linux-x64_9.9.9.count"
+        self.assertEqual(count.read_text().strip(), "1")
+
+
+if __name__ == "__main__":
+    unittest.main()

aria_code-0.61.0/tests/test_rsi_without_pandas_ta.py

@@ -0,0 +1,51 @@
+"""RSI must not go missing when pandas_ta does.
+
+The native binary leaves pandas_ta out (numba/llvmlite made the Linux npm
+package too large to publish), and on a Python numba has no wheel for it is
+installed but cannot import. Both used to report rsi_14 = None, because the
+manual fallback ran only when pandas_ta was not installed at all.
+"""
+
+from __future__ import annotations
+
+import unittest
+from unittest import mock
+
+import numpy as np
+import pandas as pd
+
+from aria_code.tools import local_finance_tools as lft
+
+
+def _history() -> pd.DataFrame:
+    rng = np.random.default_rng(7)
+    close = 100 + np.cumsum(rng.normal(0, 1, 120))
+    return pd.DataFrame({"Close": close, "Volume": rng.integers(1e5, 1e6, 120)})
+
+
+class RsiFallsBackToTheManualCalculation(unittest.TestCase):
+    def factors(self, ta) -> dict:
+        ticker = mock.Mock()
+        ticker.history.return_value = _history()
+        with mock.patch.object(lft, "_HAS_CLOUD", False), \
+             mock.patch.object(lft, "_HAS_YF", True), \
+             mock.patch.object(lft, "_HAS_TA", True), \
+             mock.patch.object(lft, "yf", mock.Mock(Ticker=mock.Mock(return_value=ticker)), create=True), \
+             mock.patch.object(lft, "_get_market_data", return_value={"success": True}), \
+             mock.patch.object(lft, "_get_pandas_ta", return_value=ta):
+            return lft._calculate_factors({"symbol": "AAPL"})
+
+    def test_installed_but_unimportable_pandas_ta_still_gives_rsi(self) -> None:
+        rsi = self.factors(ta=None).get("rsi_14")
+        self.assertIsNotNone(rsi)
+        self.assertGreaterEqual(rsi, 0)
+        self.assertLessEqual(rsi, 100)
+
+    def test_pandas_ta_is_still_used_when_it_imports(self) -> None:
+        ta = mock.Mock()
+        ta.rsi.return_value = pd.Series([42.0])
+        self.assertEqual(self.factors(ta=ta)["rsi_14"], 42.0)
+
+
+if __name__ == "__main__":
+    unittest.main()