@1aboveio/skills 0.0.0-stage → 1.0.0

package/skills/risk-compliance/tld-detection/scripts/detect_streams.test.mjs

@@ -0,0 +1,14 @@
+import assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import test from 'node:test';
+
+const skillDir = join(dirname(fileURLToPath(import.meta.url)), '..');
+
+test('TLD stream inference Python contract', () => {
+  const result = spawnSync('python3', [join(skillDir, 'tests', 'test_detect_streams.py'), '-v'], {
+    encoding: 'utf8',
+  });
+  assert.equal(result.status, 0, `${result.stdout}\n${result.stderr}`);
+});

package/skills/risk-compliance/tld-detection/tests/test_detect_ladders.py

@@ -0,0 +1,134 @@
+from collections import Counter
+import csv
+from decimal import Decimal
+import importlib.util
+import json
+from pathlib import Path
+import subprocess
+import sys
+import tempfile
+import unittest
+
+
+sys.dont_write_bytecode = True
+SCRIPT = Path(__file__).parents[1] / "scripts" / "detect_ladders.py"
+SPEC = importlib.util.spec_from_file_location("detect_ladders", SCRIPT)
+MODULE = importlib.util.module_from_spec(SPEC)
+assert SPEC.loader is not None
+sys.modules[SPEC.name] = MODULE
+SPEC.loader.exec_module(MODULE)
+
+
+def pair(amount: str) -> tuple[str, Decimal]:
+    return "USD", Decimal(amount)
+
+
+class DetectLaddersTest(unittest.TestCase):
+    def detect(self, values: dict[str, int], cap: str = "0.15"):
+        counts = Counter({pair(amount): count for amount, count in values.items()})
+        return MODULE.detect_ladders(
+            counts,
+            sum(counts.values()),
+            MODULE.LadderConfig({"USD": Decimal(cap)}),
+        )[0]
+
+    def test_detects_tight_exact_ladder(self):
+        ladders = self.detect({"28.03": 131, "56.04": 117, "112.09": 65, "224.19": 27, "70.00": 100})
+        amounts = {amount for _, amount in ladders[0]["pairs"]}
+        self.assertEqual(amounts, {Decimal("28.03"), Decimal("56.04"), Decimal("112.09"), Decimal("224.19")})
+
+    def test_keeps_multiple_exact_anchors_at_one_level(self):
+        ladders = self.detect({"14.41": 34, "14.52": 25, "28.94": 43, "57.96": 29, "80.00": 100})
+        levels = next(ladder["levels"] for ladder in ladders if pair("28.94") in ladder["pairs"])
+        self.assertEqual(levels[-1], {pair("14.41"), pair("14.52")})
+
+    def test_rejects_upper_amount_outside_absolute_cap(self):
+        ladders = self.detect({"14.41": 34, "28.94": 43, "57.96": 29, "116.85": 29, "80.00": 100})
+        ladder = next(ladder for ladder in ladders if pair("14.41") in ladder["pairs"])
+        self.assertNotIn(pair("116.85"), ladder["pairs"])
+
+    def test_requires_explicit_currency_cap(self):
+        with self.assertRaisesRegex(ValueError, "missing absolute residual cap"):
+            MODULE.detect_ladders(Counter({pair("10"): 10}), 10, MODULE.LadderConfig({}))
+
+    def test_ignores_currency_below_rung_pool_threshold(self):
+        counts = Counter({pair("10"): 1000, ("EUR", Decimal("9.99")): 1})
+        ladders, _ = MODULE.detect_ladders(counts, 1001, MODULE.LadderConfig({"USD": Decimal("0.15")}))
+        self.assertEqual(ladders, [])
+
+    def test_sensitivity_reports_coverage_by_cap(self):
+        counts = Counter({pair("14.41"): 34, pair("28.94"): 43, pair("57.96"): 29})
+        rows = MODULE.sensitivity_analysis(
+            counts,
+            sum(counts.values()),
+            MODULE.LadderConfig({"USD": Decimal("0.15")}),
+            "USD",
+            [Decimal("0.10"), Decimal("0.15")],
+        )
+        self.assertEqual([row["ladder_count"] for row in rows], [0, 1])
+
+    def test_keeps_below_threshold_family_out_of_clusters(self):
+        counts = Counter({pair("10"): 32, pair("20"): 32, pair("40"): 32})
+        ladders, metadata = MODULE.detect_ladders(
+            counts,
+            96,
+            MODULE.LadderConfig({"USD": Decimal("0.15")}),
+        )
+        self.assertEqual(ladders, [])
+        self.assertEqual(metadata["below_threshold"][0]["attempts"], 96)
+
+    def test_same_pair_can_belong_to_different_partitions(self):
+        entries = []
+        amounts = (("10", 40), ("20", 40), ("40", 40))
+        for partition in ("alpha", "beta"):
+            for amount, count in amounts:
+                entries.extend([(partition, pair(amount))] * count)
+        _, ladders, _ = MODULE.detect_partitioned_ladders(
+            entries,
+            MODULE.LadderConfig({"USD": Decimal("0.15")}),
+        )
+        self.assertEqual(len(ladders), 2)
+        self.assertEqual({ladder["partition"] for ladder in ladders}, {"alpha", "beta"})
+
+    def test_requires_at_least_three_levels(self):
+        self.assertEqual(self.detect({"10": 60, "20": 60, "70": 100}), [])
+
+    def test_rejects_non_two_x_relationships(self):
+        self.assertEqual(self.detect({"10": 40, "30": 40, "90": 40}), [])
+
+    def test_cli_keeps_whole_descriptor_despite_country_and_pattern_labels(self):
+        with tempfile.TemporaryDirectory() as directory:
+            csv_path = Path(directory) / "clean.csv"
+            with csv_path.open("w", encoding="utf-8", newline="") as handle:
+                writer = csv.DictWriter(handle, fieldnames=["descriptor", "country", "currency", "amount", "payment_pattern"])
+                writer.writeheader()
+                for country in ("US", "GB"):
+                    for amount in ("10", "20", "40"):
+                        writer.writerows(
+                            {"descriptor": "ACME", "country": country, "currency": "USD", "amount": amount,
+                             "payment_pattern": "Direct top-up pattern" if country == "US" else "E-commerce pattern"}
+                            for _ in range(20)
+                        )
+            result = subprocess.run(
+                [
+                    sys.executable,
+                    str(SCRIPT),
+                    str(csv_path),
+                    "--descriptor-column", "descriptor",
+                    "--bin-country-column", "country",
+                    "--currency-column", "currency",
+                    "--amount-column", "amount",
+                    "--cap", "USD=0.15",
+                ],
+                check=True,
+                capture_output=True,
+                text=True,
+            )
+        payload = json.loads(result.stdout)
+        self.assertEqual(len(payload["ladders"]), 1)
+        self.assertEqual(payload["ladders"][0]["partition_attempts"], 120)
+        self.assertEqual(payload["ladders"][0]["bin_country_components"], {"US": 60, "GB": 60})
+
+
+if __name__ == "__main__":
+    unittest.main()