arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/deliver.py

@@ -0,0 +1,180 @@
+#!/usr/bin/env python3
+"""Поставка порождённого модуля: пакет печатается в каталог с рантаймом,
+раннером, планом и паспортом — то, что можно отдать потребителю без движка.
+
+    python3 engines/backends/deliver.py <ir.json> --target ts --out DIR
+    python3 engines/backends/deliver.py <ir.json> --target ts --target go --out DIR
+
+Состав каталога цели задаёт дескриптор цели (`targets/<цель>/emit.py`:
+`MODEL`, `layout`, `build`, `run`, `available`): модель, рантайм, раннер и
+файлы сборки языка, плюс `plan.json` и паспорт `law-backend.json`:
+формат `law.backend-delivery/1`, версия плана, цель, паспорт пакета из
+CLIR, семантический хэш §209 самого CLIR (в снимках поле `semanticHash`
+бывает нулевым, поэтому считается здесь) и SHA-256 каждого файла. Паспорт
+связывает модуль с каноном: тот же хэш стоит у пакета в реестре и профилях.
+
+Отказ плана — отказ поставки с названной причиной и кодом 2: печатать
+«меньше пакета» нельзя, это был бы другой ответ.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import importlib.util
+import json
+import sys
+from pathlib import Path
+
+HERE = Path(__file__).resolve().parent
+ROOT = HERE.parents[1]
+sys.path.insert(0, str(HERE))
+import plan as P  # noqa: E402
+from core_support import CoreKitError  # noqa: E402
+
+FORMAT = "law.backend-delivery/1"
+
+
+def targets(protocol: str | None = None) -> list[str]:
+    """Цели — каталоги `targets/<цель>/` с эмиттером, в устойчивом порядке."""
+    names = sorted(p.name for p in (HERE / "targets").iterdir() if (p / "emit.py").exists())
+    return [n for n in names if protocol is None or getattr(emitter(n), "PROTOCOL", "runner") == protocol]
+
+
+def emitter(lang: str):
+    path = HERE / "targets" / lang / "emit.py"
+    if not path.exists():
+        raise SystemExit(f"deliver: цели {lang} нет в {HERE / 'targets'}")
+    spec = importlib.util.spec_from_file_location(f"emit_{lang}", path)
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def semantic_hash(ir: dict) -> str:
+    from core_support import semantic_hash as sh
+    return sh(ir)
+
+
+def missing_capabilities(pl: dict, em) -> list[str]:
+    """Возможности плана (DECISION-0237), которых цель не объявляет в
+    дескрипторе `CAPABILITIES`; цель без объявления печатает только L0."""
+    return sorted(set(pl.get("capabilities") or ()) - set(getattr(em, "CAPABILITIES", ())))
+
+
+def emit_project(pl: dict, lang: str, out: Path, main: str = "runner", options: dict | None = None) -> list[Path]:
+    """Файлы одной цели в каталог; возвращает список записанных путей.
+    Возможности плана сверяются с дескриптором ДО записи первого файла:
+    цель, не умеющая поражаемый слой, отказывает названной причиной, а не
+    печатает модель, молча читающую L1-план как L0."""
+    em = emitter(lang)
+    missing = missing_capabilities(pl, em)
+    if missing:
+        raise P.Refused(f"цель {lang} не поддерживает возможности плана: {', '.join(missing)}")
+    # Workbook targets have a bounded input contract and no JSON runner.
+    # Prepare everything before touching the destination, including refusals.
+    if getattr(em, "PROTOCOL", "runner") == "workbook":
+        if main != "runner":
+            raise P.Refused(f"цель {lang}: протокол workbook, нет раннера {main}")
+        artifacts = em.artifacts(pl, options)
+        out = Path(out)
+        out.mkdir(parents=True, exist_ok=True)
+        written = []
+        for name, data in artifacts.items():
+            path = out / name
+            path.write_bytes(data)
+            written.append(path)
+        return written
+    out = Path(out)
+    out.mkdir(parents=True, exist_ok=True)
+    written = em.layout(out, main)
+    if main == "runner":
+        model = out / em.MODEL
+        model.parent.mkdir(parents=True, exist_ok=True)
+        model.write_text(em.emit(pl), encoding="utf-8")
+        written.append(model)
+        # Поверхность API (DECISION-0234): именованные функции над моделью.
+        # Печатает только цель с `API`/`emit_api`; остальные отдают модуль
+        # без обёртки — это не «меньше ответа», обёртка семантики не несёт.
+        if getattr(em, "API", None) and hasattr(em, "emit_api"):
+            api = out / em.API
+            api.write_text(em.emit_api(pl), encoding="utf-8")
+            written.append(api)
+    return written
+
+
+def deliver(ir: dict, lang: str, out: Path, world: list | None = None, options: dict | None = None,
+            resources: dict | None = None) -> dict:
+    """Поставка одной цели с паспортом; план строится один раз на вызов.
+    `world` — CLIR зависимостей (DECISION-0236): без него пакет с импортом
+    отказывает планом."""
+    pl = P.build_plan(ir, world, resources=resources)
+    out = Path(out)
+    digest = semantic_hash(ir)
+    if getattr(emitter(lang), "PROTOCOL", "runner") == "workbook":
+        if options is not None and not isinstance(options, dict):
+            raise P.Refused("конфигурация workbook должна быть объектом")
+        options = dict(options or {}, semanticHash=digest)
+    files = emit_project(pl, lang, out, options=options)
+    (out / "plan.json").write_text(json.dumps(pl, ensure_ascii=False, indent=1) + "\n", encoding="utf-8")
+    files.append(out / "plan.json")
+    passport = {
+        "format": FORMAT,
+        "planVersion": pl["planVersion"],
+        "target": lang,
+        "package": ir.get("package"),
+        "semanticHash": digest,
+        "world": pl.get("world", []),
+        "profile": getattr(emitter(lang), "PROFILE", "core-executable"),
+        "files": {f.relative_to(out).as_posix(): "sha256:" + hashlib.sha256(f.read_bytes()).hexdigest()
+                  for f in sorted(files)},
+    }
+    (out / "law-backend.json").write_text(json.dumps(passport, ensure_ascii=False, indent=1) + "\n",
+                                          encoding="utf-8")
+    return passport
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser()
+    ap.add_argument("ir", type=Path, help="CLIR пакета (*.lawir.json)")
+    ap.add_argument("--target", action="append", choices=targets(), required=True)
+    ap.add_argument("--out", type=Path, required=True, help="каталог поставки; цели в подкаталогах")
+    ap.add_argument("--dep", type=Path, action="append", default=[],
+                    help="CLIR зависимости (можно повторять)")
+    ap.add_argument("--corpus-root", type=Path,
+                    help="явный корень corpus/clir и packs для переходного адаптера law-dsl")
+    ap.add_argument("--resources", type=Path,
+                    help="JSON: URI → {path, sha256}; пути относительно JSON")
+    ap.add_argument("--core-kit", type=Path, help="проверенный комплект поддержки ядра")
+    ap.add_argument("--xlsx-config", type=Path, help="границы и начальные данные Excel (excel-calculator/0.1)")
+    args = ap.parse_args()
+    if args.core_kit:
+        import os
+        os.environ["LAW_CODEGEN_CORE_KIT"] = str(args.core_kit.resolve())
+    if args.xlsx_config and "xlsx" not in args.target:
+        ap.error("--xlsx-config требует --target xlsx")
+    ir = json.loads(args.ir.read_text(encoding="utf-8"))
+    try:
+        extra = [json.loads(p.read_text(encoding="utf-8")) for p in args.dep]
+        from inputs import dependency_index, load_resources, corpus_resources
+        index = P.world_index(args.corpus_root) if args.corpus_root else {}
+        # Validate explicit dependencies even when the root has no imports.
+        dependency_index(extra)
+        world = P.resolve_world(ir, index, extra) if ir.get("imports") else []
+        resources = load_resources(args.resources) if args.resources else (corpus_resources([ir, *world], args.corpus_root) if args.corpus_root else {})
+        config = json.loads(args.xlsx_config.read_text(encoding="utf-8")) if args.xlsx_config else None
+        for lang in args.target:
+            passport = deliver(ir, lang, args.out / lang, world, config if lang == "xlsx" else None,
+                               resources=resources)
+            print(f"deliver: {lang} → {args.out / lang} ({passport['package'].get('name')}, "
+                  f"{passport['semanticHash'][:19]}…)")
+    except P.Refused as exc:
+        print(f"deliver: отказ плана — {exc}", file=sys.stderr)
+        return 2
+    except CoreKitError as exc:
+        print(f"deliver: ошибка комплекта ядра — {exc}", file=sys.stderr)
+        return 1
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

arxo_codegen/examples/xlsx/pricing.lawir.json

@@ -0,0 +1,409 @@
+{
+  "schemaVersion": "law.core.ir/0.2",
+  "semanticVersion": "0.1.1",
+  "features": [
+    "core-executable"
+  ],
+  "imports": [],
+  "metadata": {},
+  "strata": [],
+  "package": {
+    "name": "example.excel",
+    "namespace": "urn:law:example:excel",
+    "version": "0.1.0"
+  },
+  "nodes": [
+    {
+      "id": "urn:law:example:excel#quote",
+      "kind": "symbol_decl",
+      "symbolKind": "relation",
+      "name": "quote",
+      "package": "urn:law:example:excel",
+      "relationKind": "institutional",
+      "keys": [],
+      "parameters": [
+        {
+          "id": "urn:law:example:excel#quote/arg/0",
+          "name": "arg0",
+          "type": {
+            "name": "urn:law:std#Text"
+          }
+        },
+        {
+          "id": "urn:law:example:excel#quote/arg/1",
+          "name": "arg1",
+          "type": {
+            "name": "urn:law:std#Text"
+          }
+        },
+        {
+          "id": "urn:law:example:excel#quote/arg/2",
+          "name": "arg2",
+          "type": {
+            "name": "urn:law:std#Money"
+          }
+        }
+      ]
+    },
+    {
+      "id": "urn:law:example:excel#rate",
+      "kind": "symbol_decl",
+      "symbolKind": "relation",
+      "name": "rate",
+      "package": "urn:law:example:excel",
+      "relationKind": "institutional",
+      "keys": [],
+      "parameters": [
+        {
+          "id": "urn:law:example:excel#rate/arg/0",
+          "name": "arg0",
+          "type": {
+            "name": "urn:law:std#Text"
+          }
+        },
+        {
+          "id": "urn:law:example:excel#rate/arg/1",
+          "name": "arg1",
+          "type": {
+            "name": "urn:law:std#Decimal"
+          }
+        }
+      ]
+    },
+    {
+      "id": "urn:law:example:excel#premium",
+      "kind": "symbol_decl",
+      "symbolKind": "relation",
+      "name": "premium",
+      "package": "urn:law:example:excel",
+      "relationKind": "institutional",
+      "keys": [
+        [
+          0
+        ]
+      ],
+      "parameters": [
+        {
+          "id": "urn:law:example:excel#premium/arg/0",
+          "name": "arg0",
+          "type": {
+            "name": "urn:law:std#Text"
+          }
+        },
+        {
+          "id": "urn:law:example:excel#premium/arg/1",
+          "name": "arg1",
+          "type": {
+            "name": "urn:law:std#Money"
+          }
+        }
+      ]
+    },
+    {
+      "id": "urn:law:example:excel#Rate0",
+      "kind": "assertion",
+      "package": "urn:law:example:excel",
+      "literal": {
+        "kind": "literal",
+        "predicate": "urn:law:example:excel#rate",
+        "polarity": "positive",
+        "args": [
+          {
+            "kind": "value",
+            "type": {
+              "name": "urn:law:std#Text"
+            },
+            "value": "A"
+          },
+          {
+            "kind": "value",
+            "type": {
+              "name": "urn:law:std#Decimal"
+            },
+            "value": "1.10"
+          }
+        ]
+      },
+      "origin": "source_asserted",
+      "evidence": []
+    },
+    {
+      "id": "urn:law:example:excel#Rate1",
+      "kind": "assertion",
+      "package": "urn:law:example:excel",
+      "literal": {
+        "kind": "literal",
+        "predicate": "urn:law:example:excel#rate",
+        "polarity": "positive",
+        "args": [
+          {
+            "kind": "value",
+            "type": {
+              "name": "urn:law:std#Text"
+            },
+            "value": "B"
+          },
+          {
+            "kind": "value",
+            "type": {
+              "name": "urn:law:std#Decimal"
+            },
+            "value": "1.25"
+          }
+        ]
+      },
+      "origin": "source_asserted",
+      "evidence": []
+    },
+    {
+      "id": "urn:law:example:excel#Price",
+      "kind": "rule",
+      "package": "urn:law:example:excel",
+      "strength": "strict",
+      "head": {
+        "kind": "literal",
+        "predicate": "urn:law:example:excel#premium",
+        "polarity": "positive",
+        "args": [
+          {
+            "kind": "var",
+            "var": "I"
+          },
+          {
+            "kind": "call",
+            "function": "urn:law:std#round",
+            "args": [
+              {
+                "kind": "binary",
+                "op": "mul",
+                "left": {
+                  "kind": "var",
+                  "var": "B"
+                },
+                "right": {
+                  "kind": "var",
+                  "var": "K"
+                }
+              },
+              {
+                "kind": "value",
+                "type": {
+                  "name": "urn:law:std#Integer"
+                },
+                "value": 2
+              },
+              {
+                "kind": "value",
+                "type": {
+                  "name": "urn:law:std#Text"
+                },
+                "value": "HALF_UP"
+              }
+            ]
+          }
+        ]
+      },
+      "body": {
+        "kind": "and",
+        "items": [
+          {
+            "kind": "status",
+            "status": "established",
+            "formula": {
+              "kind": "literal",
+              "predicate": "urn:law:example:excel#quote",
+              "polarity": "positive",
+              "args": [
+                {
+                  "kind": "var",
+                  "var": "I"
+                },
+                {
+                  "kind": "var",
+                  "var": "C"
+                },
+                {
+                  "kind": "var",
+                  "var": "B"
+                }
+              ]
+            }
+          },
+          {
+            "kind": "status",
+            "status": "established",
+            "formula": {
+              "kind": "literal",
+              "predicate": "urn:law:example:excel#rate",
+              "polarity": "positive",
+              "args": [
+                {
+                  "kind": "var",
+                  "var": "C"
+                },
+                {
+                  "kind": "var",
+                  "var": "K"
+                }
+              ]
+            }
+          },
+          {
+            "kind": "comparison",
+            "op": "ge",
+            "left": {
+              "kind": "var",
+              "var": "B"
+            },
+            "right": {
+              "kind": "value",
+              "type": {
+                "name": "urn:law:std#Money"
+              },
+              "value": "0",
+              "currency": "KZT"
+            }
+          }
+        ]
+      },
+      "variables": [],
+      "scope": {
+        "kind": "boolean",
+        "value": true
+      },
+      "interpretations": [],
+      "effective": {
+        "axis": "legal_time",
+        "start": "2026-01-01",
+        "end": "2027-01-01",
+        "startInclusive": true,
+        "endInclusive": false
+      }
+    },
+    {
+      "id": "urn:law:example:excel#PriceAgain",
+      "kind": "rule",
+      "package": "urn:law:example:excel",
+      "strength": "strict",
+      "head": {
+        "kind": "literal",
+        "predicate": "urn:law:example:excel#premium",
+        "polarity": "positive",
+        "args": [
+          {
+            "kind": "var",
+            "var": "I"
+          },
+          {
+            "kind": "call",
+            "function": "urn:law:std#round",
+            "args": [
+              {
+                "kind": "binary",
+                "op": "mul",
+                "left": {
+                  "kind": "var",
+                  "var": "B"
+                },
+                "right": {
+                  "kind": "var",
+                  "var": "K"
+                }
+              },
+              {
+                "kind": "value",
+                "type": {
+                  "name": "urn:law:std#Integer"
+                },
+                "value": 2
+              },
+              {
+                "kind": "value",
+                "type": {
+                  "name": "urn:law:std#Text"
+                },
+                "value": "HALF_UP"
+              }
+            ]
+          }
+        ]
+      },
+      "body": {
+        "kind": "and",
+        "items": [
+          {
+            "kind": "status",
+            "status": "established",
+            "formula": {
+              "kind": "literal",
+              "predicate": "urn:law:example:excel#quote",
+              "polarity": "positive",
+              "args": [
+                {
+                  "kind": "var",
+                  "var": "I"
+                },
+                {
+                  "kind": "var",
+                  "var": "C"
+                },
+                {
+                  "kind": "var",
+                  "var": "B"
+                }
+              ]
+            }
+          },
+          {
+            "kind": "status",
+            "status": "established",
+            "formula": {
+              "kind": "literal",
+              "predicate": "urn:law:example:excel#rate",
+              "polarity": "positive",
+              "args": [
+                {
+                  "kind": "var",
+                  "var": "C"
+                },
+                {
+                  "kind": "var",
+                  "var": "K"
+                }
+              ]
+            }
+          },
+          {
+            "kind": "comparison",
+            "op": "ge",
+            "left": {
+              "kind": "var",
+              "var": "B"
+            },
+            "right": {
+              "kind": "value",
+              "type": {
+                "name": "urn:law:std#Money"
+              },
+              "value": "0",
+              "currency": "KZT"
+            }
+          }
+        ]
+      },
+      "variables": [],
+      "scope": {
+        "kind": "boolean",
+        "value": true
+      },
+      "interpretations": [],
+      "effective": {
+        "axis": "legal_time",
+        "start": "2026-01-01",
+        "end": "2027-01-01",
+        "startInclusive": true,
+        "endInclusive": false
+      }
+    }
+  ]
+}

arxo_codegen/examples/xlsx/pricing.xlsx.json

@@ -0,0 +1,52 @@
+{
+  "profile": "excel-calculator/0.1",
+  "currency": "KZT",
+  "legalTime": "2026-09-15",
+  "tables": {
+    "urn:law:example:excel#quote": {
+      "rows": 2,
+      "values": [
+        [
+          "POLICY-1",
+          "A",
+          "100.05"
+        ]
+      ],
+      "scales": [
+        0,
+        0,
+        2
+      ],
+      "label": "Данные расчёта",
+      "columns": [
+        "Полис",
+        "Категория",
+        "Базовая сумма, KZT"
+      ]
+    },
+    "urn:law:example:excel#rate": {
+      "rows": 0,
+      "scales": [
+        0,
+        2
+      ],
+      "label": "Коэффициенты примера",
+      "columns": [
+        "Категория",
+        "Коэффициент"
+      ]
+    },
+    "urn:law:example:excel#premium": {
+      "rows": 0,
+      "scales": [
+        0,
+        2
+      ],
+      "label": "Расчётная сумма",
+      "columns": [
+        "Полис",
+        "Сумма, KZT"
+      ]
+    }
+  }
+}