arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/py/api_base.py

@@ -0,0 +1,334 @@
+"""Общая часть API порождённого модуля (DECISION-0423 §2.1, §2.4, §2.5).
+
+Значения входа — литерал-термы §53 с явным видом: `integer`, `decimal`,
+`money`, `text`, `entity` и другие конструкторы строят ту же каноническую
+запись, что векторы и оракул. Факты и вопрос уходят в единый вход
+`evaluate` — тот же, что у раннера, поэтому сверка аргументов §189, статусы
+§175 и issues у API и раннера одни. Семантики здесь нет.
+
+Ошибка формы вызова — `InputError`: значение не того вида для параметра или
+запись, которую конструктор литерала не принимает. Названный отказ среза —
+`Refused`. Семантический `TYPE_ERROR` (например, Decimal в слоте сущности,
+поданный конструктором `decimal`) — issue и статус ответа, не исключение.
+"""
+from __future__ import annotations
+
+import datetime as _dt
+import decimal as _decimal
+import json as _json
+import re as _re
+from dataclasses import dataclass
+
+import runtime as RT
+from evaluate import evaluate as _evaluate
+
+Refused = RT.Refused
+
+STD = "urn:law:std#"
+INT, NAT, DEC, MON = STD + "Integer", STD + "Natural", STD + "Decimal", STD + "Money"
+QTY, RAT, TEXT, BOOL = STD + "Quantity", STD + "Rational", STD + "Text", STD + "Boolean"
+DATE, INSTANT = STD + "Date", STD + "Instant"
+
+_DATE_RE = _re.compile(r"^[0-9]{4}-[0-9]{2}-[0-9]{2}\Z")
+_INSTANT_RE = _re.compile(r"^[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(?:\.[0-9]+)?(?:Z|[+-][0-9]{2}:[0-9]{2})?\Z")
+
+
+class InputError(ValueError):
+    """Ошибка формы вызова API (DECISION-0423 §2.5)."""
+
+
+@dataclass(frozen=True)
+class Term:
+    """Литерал-терм §53 входа или результата: `value` с std-типом и записью
+    §208, `entity_ref` или `const_ref`. Неизменяем и сравним по значению записи."""
+    kind: str
+    type: str | None = None
+    value: object = None
+    currency: str | None = None
+    unit: str | None = None
+    id: str | None = None
+
+    def to_node(self) -> dict:
+        if self.kind in ("entity_ref", "const_ref"):
+            return {"kind": self.kind, "id": self.id}
+        node = {"kind": "value", "type": {"name": self.type}, "value": self.value}
+        if self.currency is not None:
+            node["currency"] = self.currency
+        if self.unit is not None:
+            node["unit"] = self.unit
+        return node
+
+    @staticmethod
+    def from_node(node: dict) -> "Term":
+        kind = node.get("kind")
+        if kind in ("entity_ref", "const_ref"):
+            return Term(kind, id=node.get("id"))
+        if kind == "value":
+            return Term("value", type=(node.get("type") or {}).get("name"), value=node.get("value"),
+                        currency=node.get("currency"), unit=node.get("unit"))
+        raise InputError(f"литерал-терм §53 неизвестного вида: {kind!r}")
+
+
+# Представление значения между канонами (DECISION-0423 §2.7): канонический
+# JSON литерал-терма §53 — ключи по порядку, без пробелов, Integer — числом.
+VALUE_FORMAT = "law.codegen-value/1"
+
+
+def to_value(term: Term) -> str:
+    """Значение для другого модуля канона или сервиса: текст формата `VALUE_FORMAT`."""
+    if not isinstance(term, Term):
+        raise InputError("to_value: ожидается литерал-терм (Term)")
+    return _json.dumps(term.to_node(), ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+
+
+def from_value(text: str) -> Term:
+    """Литерал-терм из текста формата `VALUE_FORMAT`."""
+    try:
+        node = _json.loads(text)
+    except (TypeError, ValueError) as exc:
+        raise InputError(f"from_value: не JSON — {exc}") from exc
+    if not isinstance(node, dict):
+        raise InputError("from_value: ожидается объект литерал-терма §53")
+    return Term.from_node(node)
+
+
+def _checked(fn, *args):
+    try:
+        return fn(*args)
+    except (RT.TermError, RT.Refused) as exc:
+        raise InputError(str(getattr(exc, "code", exc))) from None
+
+
+def integer(v: int) -> Term:
+    """Integer §208: целое языка в знаковом 64-битном диапазоне."""
+    if isinstance(v, bool) or not isinstance(v, int):
+        raise InputError(f"integer: ожидается int, получено {type(v).__name__}")
+    _checked(RT.lit_int_text, v)
+    return Term("value", type=INT, value=v)
+
+
+def natural(v: int) -> Term:
+    """Natural §208: неотрицательное целое в знаковом 64-битном диапазоне."""
+    if isinstance(v, bool) or not isinstance(v, int) or v < 0:
+        raise InputError(f"natural: ожидается неотрицательный int, получено {v!r}")
+    _checked(RT.lit_int_text, v)
+    return Term("value", type=NAT, value=v)
+
+
+def _decimal_record(v, where: str):
+    if isinstance(v, bool):
+        raise InputError(f"{where}: ожидается десятичная запись, получено bool")
+    if isinstance(v, _decimal.Decimal):
+        if not v.is_finite():
+            raise InputError(f"{where}: {v} не конечное число")
+        v = str(v)
+    if isinstance(v, int):
+        _checked(RT.lit_int_text, v)
+        return v
+    if not isinstance(v, str):
+        raise InputError(f"{where}: ожидается строка по лексике §208, Decimal или int, получено {type(v).__name__}")
+    _checked(RT.lit_dec_text, v)
+    return v
+
+
+def decimal(v) -> Term:
+    """Decimal §208: строка по лексике §208, `decimal.Decimal` или целое; без float."""
+    return Term("value", type=DEC, value=_decimal_record(v, "decimal"))
+
+
+def money(amount, currency: str) -> Term:
+    """Money §208: десятичная сумма и обязательная валюта."""
+    if not isinstance(currency, str) or not currency:
+        raise InputError("money: валюта обязательна")
+    return Term("value", type=MON, value=_decimal_record(amount, "money"), currency=currency)
+
+
+def quantity(value, unit: str) -> Term:
+    """Quantity §49 v1: десятичное значение и тег единицы как записан."""
+    if not isinstance(unit, str) or not unit:
+        raise InputError("quantity: единица обязательна")
+    return Term("value", type=QTY, value=_decimal_record(value, "quantity"), unit=unit)
+
+
+def rational(v: str) -> Term:
+    """Rational §35: каноническая запись `n/d` (§168.1)."""
+    if not isinstance(v, str):
+        raise InputError(f"rational: ожидается строка n/d, получено {type(v).__name__}")
+    _checked(RT.rat, v)
+    return Term("value", type=RAT, value=v)
+
+
+def text(v: str) -> Term:
+    """Text: строка как есть."""
+    if not isinstance(v, str):
+        raise InputError(f"text: ожидается str, получено {type(v).__name__}")
+    return Term("value", type=TEXT, value=v)
+
+
+def boolean(v: bool) -> Term:
+    if not isinstance(v, bool):
+        raise InputError(f"boolean: ожидается bool, получено {type(v).__name__}")
+    return Term("value", type=BOOL, value=v)
+
+
+def date(v) -> Term:
+    """Date §2.15: календарный день ISO `YYYY-MM-DD` или `datetime.date`."""
+    if isinstance(v, _dt.datetime):
+        raise InputError("date: ожидается календарный день, получено datetime")
+    if isinstance(v, _dt.date):
+        return Term("value", type=DATE, value=v.isoformat())
+    if not isinstance(v, str) or not _DATE_RE.match(v):
+        raise InputError(f"date: ожидается запись YYYY-MM-DD, получено {v!r}")
+    try:
+        _dt.date.fromisoformat(v)
+    except ValueError:
+        raise InputError(f"date: несуществующий день {v!r}") from None
+    return Term("value", type=DATE, value=v)
+
+
+def instant(v) -> Term:
+    """Instant §2.15: запись ISO-мгновения, смещение — часть записи (E-0214)."""
+    if isinstance(v, _dt.datetime):
+        return Term("value", type=INSTANT, value=v.isoformat())
+    if not isinstance(v, str) or not _INSTANT_RE.match(v):
+        raise InputError(f"instant: ожидается запись ISO-мгновения, получено {v!r}")
+    try:
+        _dt.datetime.fromisoformat(v.replace("Z", "+00:00"))
+    except ValueError:
+        raise InputError(f"instant: несуществующее мгновение {v!r}") from None
+    return Term("value", type=INSTANT, value=v)
+
+
+def entity(id: str) -> Term:                                     # noqa: A002
+    """Ссылка на сущность: идентичность, типа не несёт (§189, как у оракула)."""
+    if not isinstance(id, str) or not id:
+        raise InputError("entity: ожидается непустой идентификатор")
+    return Term("entity_ref", id=id)
+
+
+def member(id: str) -> Term:                                     # noqa: A002
+    """Член перечисления §38 или константа §54 — ссылка `const_ref`."""
+    if not isinstance(id, str) or not id:
+        raise InputError("member: ожидается непустой идентификатор")
+    return Term("const_ref", id=id)
+
+
+@dataclass(frozen=True)
+class Fact:
+    """Утверждение дела: предикат и литерал-термы аргументов; `negative` —
+    отрицательный факт §113 (только модель L1)."""
+    predicate: str
+    args: tuple
+    negative: bool = False
+
+
+@dataclass(frozen=True)
+class Answer:
+    """Ответ исполняемого профиля, один для всех целей и слоёв (DECISION-0423 §2.1).
+
+    `truth_status` — у вопроса истинности (`result_kind == "PROPOSITION"`),
+    `rows` — у перечисления строк (`"COLLECTION"`). Хэшей и доказательства нет:
+    профиль `core-executable`."""
+    query_id: str
+    result_kind: str
+    truth_status: str | None
+    evaluation_status: str
+    issues: tuple = ()
+    judgment_requests: tuple = ()
+    rows: tuple | None = None
+
+
+def slot(types: tuple, kinds: tuple, i: int, v, where: str) -> Term:
+    """Значение `i`-го параметра: `Term` проходит как есть (сверка §189 — в
+    `evaluate`), значение языка переводится по объявленному типу слота; вид,
+    который по типу слота не читается однозначно, — `InputError`."""
+    if isinstance(v, Term):
+        return v
+    t, k = types[i], kinds[i]
+    if isinstance(v, bool):
+        if t == BOOL:
+            return boolean(v)
+    elif isinstance(v, int):
+        if t == INT:
+            return integer(v)
+        if t == NAT:
+            return natural(v)
+        if t == DEC:
+            return decimal(v)
+    elif isinstance(v, _decimal.Decimal):
+        if t == DEC:
+            return decimal(v)
+    elif isinstance(v, _dt.datetime):
+        if t == INSTANT:
+            return instant(v)
+    elif isinstance(v, _dt.date):
+        if t == DATE:
+            return date(v)
+    elif isinstance(v, str):
+        if t == TEXT:
+            return text(v)
+        if t == DATE:
+            return date(v)
+        if t == INSTANT:
+            return instant(v)
+        if t == DEC:
+            return decimal(v)
+        if t == RAT:
+            return rational(v)
+        if not t.startswith(STD):
+            return member(v) if k == "enum" else entity(v)
+    raise InputError(f"{where}: аргумент {i + 1} — для типа {t} нужен конструктор литерала "
+                     f"(integer, decimal, money, text, date, entity, …), получено {type(v).__name__}")
+
+
+def fact(pred: str, types: tuple, kinds: tuple, args: tuple, where: str, negative: bool = False) -> Fact:
+    if len(args) != len(types):
+        raise InputError(f"{where}: ожидается аргументов {len(types)}, получено {len(args)}")
+    return Fact(pred, tuple(slot(types, kinds, i, a, where) for i, a in enumerate(args)), negative)
+
+
+def legal_time(on) -> str:
+    """Правовое время дела §31: календарный день ISO или `datetime.date`."""
+    if isinstance(on, _dt.date) and not isinstance(on, _dt.datetime):
+        return on.isoformat()
+    if isinstance(on, str) and _DATE_RE.match(on):
+        try:
+            _dt.date.fromisoformat(on)
+            return on
+        except ValueError:
+            pass
+    raise InputError(f"on: ожидается календарный день YYYY-MM-DD, получено {on!r}")
+
+
+def case_of(facts, on) -> dict:
+    assertions = []
+    for f in facts:
+        if not isinstance(f, Fact):
+            raise InputError(f"facts: ожидается Fact из fact_*/negated_*, получено {type(f).__name__}")
+        assertions.append({"literal": {"kind": "literal", "predicate": f.predicate,
+                                       "polarity": "negative" if f.negative else "positive",
+                                       "args": [a.to_node() for a in f.args]}})
+    return {"context": {"legalTime": legal_time(on)}, "assertions": assertions}
+
+
+def ask(pred: str, types: tuple, kinds: tuple, facts, on, args: tuple, name: str, query_id: str | None) -> Answer:
+    """Вопрос истинности: статус §62 атома, статус вычисления §175, issues."""
+    if len(args) != len(types):
+        raise InputError(f"ask_{name}: ожидается аргументов {len(types)}, получено {len(args)}")
+    literal = {"kind": "literal", "predicate": pred, "polarity": "positive",
+               "args": [slot(types, kinds, i, a, "ask_" + name).to_node() for i, a in enumerate(args)]}
+    query = {"kind": "truth", "queryId": query_id or "urn:query:api:" + name, "literal": literal}
+    doc = _evaluate(case_of(facts, on), query, api=True)
+    return Answer(query_id=doc["queryId"], result_kind="PROPOSITION", truth_status=doc["truthStatus"],
+                  evaluation_status=doc["evaluationStatus"], issues=tuple(doc["issues"]),
+                  judgment_requests=tuple(doc.get("judgmentRequests") or ()))
+
+
+def rows(pred: str, facts, on, name: str, query_id: str | None) -> Answer:
+    """Установленные строки вопроса литерал-термами §53 (DECISION-0423 §2.1)."""
+    query = {"kind": "rows", "queryId": query_id or "urn:query:api:rows:" + name, "predicate": pred}
+    doc = _evaluate(case_of(facts, on), query, api=True)
+    return Answer(query_id=doc["queryId"], result_kind="COLLECTION", truth_status=None,
+                  evaluation_status=doc["evaluationStatus"], issues=tuple(doc["issues"]),
+                  judgment_requests=tuple(doc.get("judgmentRequests") or ()),
+                  rows=tuple(tuple(Term.from_node(n) for n in r) for r in doc["rows"]))

arxo_codegen/targets/py/apicheck.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""Харнесс проверки API: читает задание {question, on, args, facts, queryId} с
+литерал-термами §53 и отвечает через `api.QUESTIONS`/`api.INPUTS` в том же
+виде, что раннер, — ворота сверяют API с раннером и между целями.
+
+Аргументы подаются явными литерал-термами (`api.Term`), поэтому задание может
+нести и неверно типизированное значение: сверка §189 — в `evaluate`, общем с
+раннером. Поля ответа берутся из `Answer` как есть, без подстановок
+(DECISION-0423 §2.6). Пакет `{"batch": [...], "concurrent": bool}` исполняется
+одним процессом — последовательно или потоками — и печатает `{"answers": [...]}`:
+так ворота видят, что состояние между вызовами не протекает."""
+import json
+import sys
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import runtime as RT   # noqa: E402
+import api             # noqa: E402
+
+
+def answer(job: dict) -> dict:
+    try:
+        facts = [(api.NEGATED if f.get("polarity") == "negative" else api.INPUTS)[f["input"]](
+                     *[api.Term.from_node(x) for x in f["args"]])
+                 for f in job["facts"]]
+        a = api.QUESTIONS[job["question"]](facts, job["on"], *[api.Term.from_node(x) for x in job["args"]],
+                                           query_id=job.get("queryId"))
+    except RT.Refused as exc:
+        return {"refused": str(exc)}
+    return {"queryId": a.query_id, "truthStatus": a.truth_status, "evaluationStatus": a.evaluation_status,
+            "judgmentRequests": list(a.judgment_requests), "issues": list(a.issues)}
+
+
+def main() -> int:
+    job = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
+    if "batch" in job:
+        batch = job["batch"]
+        if job.get("concurrent"):
+            with ThreadPoolExecutor(max_workers=8) as pool:
+                answers = list(pool.map(answer, batch))
+        else:
+            answers = [answer(j) for j in batch]
+        print(json.dumps({"answers": answers}, ensure_ascii=False))
+        return 0
+    out = answer(job)
+    print(json.dumps(out, ensure_ascii=False))
+    return 3 if "refused" in out else 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

arxo_codegen/targets/py/cert.py

@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""Харнесс сертификации рантайма: исполняет runtime-cert.json и печатает,
+что получилось. Ожидания сверяют ворота, харнесс их не читает — он не
+должен знать, что считается правильным."""
+import json
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+import runtime as RT   # noqa: E402
+
+
+def lit(x):
+    if isinstance(x, str):
+        return x
+    if "dec" in x:
+        return RT.dec(x["dec"])
+    if "money" in x:
+        return RT.money(x["money"], x["cur"])
+    if "text" in x:
+        return x["text"]
+    if "date" in x:
+        return RT.date(x["date"])
+    if "instant" in x:
+        return RT.instant(x["instant"])
+    if "sym" in x:
+        return RT.sym(x["sym"])
+    if "rat" in x:
+        return RT.rat(x["rat"])
+    if "qty" in x:
+        return RT.qty(x["qty"], x["unit"])
+    if "bool" in x:
+        return bool(x["bool"])
+    if "row" in x:
+        return [lit(v) for v in x["row"]]
+    raise AssertionError(x)
+
+
+def digits(u: int, s: int) -> str:
+    """Отображение с ЯВНЫМ масштабом: 2.00 и 2 — разные записи одного значения."""
+    neg = u < 0
+    body = str(-u if neg else u).rjust(s + 1, "0")
+    text = body if s == 0 else body[:-s] + "." + body[-s:]
+    return ("-" if neg else "") + text
+
+
+def render(v):
+    if v is None or isinstance(v, (bool, str)):
+        return v
+    if isinstance(v, RT.Money):
+        return digits(v.u, v.s) + " " + v.cur
+    if isinstance(v, RT.Date):
+        return v.v
+    if isinstance(v, RT.Instant):
+        return v.v
+    if isinstance(v, RT.Sym):
+        return v.id
+    if isinstance(v, RT.Rat):
+        return f"{v.n}/{v.d}"
+    if isinstance(v, RT.Qty):
+        return digits(v.u, v.s) + " [" + v.unit + "]"
+    return digits(v.u, v.s)
+
+
+def run(case: dict):
+    op, a = case["op"], [lit(x) for x in case["args"]]
+    if op == "dec":
+        return RT.dec(a[0])
+    if op == "money":
+        return RT.money(a[0], a[1])
+    if op == "date":
+        return RT.date(a[0])
+    if op == "instant":
+        return RT.instant(a[0])
+    if op == "hoursBetween":
+        return RT.hours_between(a[0], a[1])
+    if op == "minutesBetween":
+        return RT.minutes_between(a[0], a[1])
+    if op == "addDuration":
+        return RT.add_duration(a[0], int(a[1]), a[2])
+    if op == "sym":
+        return RT.sym(a[0])
+    if op == "rat":
+        return RT.rat(a[0])
+    if op == "ratTerm":
+        return RT.rat_term(a[0])
+    if op == "qty":
+        return RT.qty(a[0], a[1])
+    if op == "counter":
+        n, unit = RT.counter(a[0], a[1])
+        return f"{n} {unit}"
+    if op == "arith":
+        return RT.arith(a[0], a[1], a[2], a[3], a[4])
+    if op == "mul":
+        return RT.mul(a[0], a[1])
+    if op == "round":
+        return RT.round(a[0], a[1], a[2])
+    if op == "roundMode":
+        return RT.round_mode(a[0], a[1], a[2], a[3], a[4])
+    if op == "divRound":
+        return RT.div_round(a[0], a[1], a[2], a[3], a[4], a[5], a[6])
+    if op == "cmp":
+        return RT.cmp(a[0], a[1], a[2])
+    if op == "eq":
+        return RT.eq(a[0], a[1])
+    if op in ("add", "sub", "div", "mod", "min", "max", "pow"):
+        return getattr(RT, op)(a[0], a[1])
+    if op == "abs":
+        return RT.abs(a[0])
+    if op == "monthStart":
+        return RT.month_start(a[0])
+    if op == "monthEnd":
+        return RT.month_end(a[0])
+    if op == "keyEq":
+        return RT.key(a[0]) == RT.key(a[1])
+    if op == "legalTime":
+        return RT.legal_time()
+    if op == "setLegalTime":
+        RT.set_legal_time(a[0])
+        return None
+    raise AssertionError("неизвестная операция фикстуры: " + op)
+
+
+def main() -> None:
+    fixture = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
+    out = []
+    for case in fixture["cases"]:
+        try:
+            got = render(run(case))
+        except RT.Refused as exc:
+            got = {"refused": str(exc)}
+        except RT.TermError as exc:
+            got = {"termError": exc.code}
+        out.append({"id": case["id"], "got": got})
+    print(json.dumps(out, ensure_ascii=False))
+
+
+if __name__ == "__main__":
+    main()