arxo-codegen 0.4.0__py3-none-any.whl

arxo_codegen/targets/java/emit.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""Эмиттер Java. Модель — класс `Model` со статическими таблицами и правилами."""
+import json
+import shutil
+import sys
+from pathlib import Path
+
+SUPPORTED_PLAN = "law-backend-plan/0.7"
+
+
+def check_plan(plan: dict) -> None:
+    v = plan.get("planVersion")
+    if v != SUPPORTED_PLAN:
+        raise ValueError(f"версия плана не поддержана эмиттером: {v!r} (поддержана {SUPPORTED_PLAN})")
+
+
+def jstr(s: str) -> str:
+    return json.dumps(s, ensure_ascii=False)
+
+
+def key_readers(plan: dict) -> dict[str, list[str]]:
+    readers: dict[str, set[str]] = {}
+    for rule in plan["rules"]:
+        for atom in rule.get("atoms") or []:
+            readers.setdefault(atom["pred"], set()).add(rule["head"]["pred"])
+        for check in rule.get("checks") or []:
+            readers.setdefault(check["pred"], set()).add(rule["head"]["pred"])
+    return {source: sorted(consumers) for source, consumers in sorted(readers.items())}
+
+
+def term(t: dict) -> str:
+    k = t["k"]
+    if k == "var":
+        return f'r{t["row"]}.get({t["col"]})'
+    if k == "lit":
+        if t["t"] == "money":
+            return f'Runtime.money({jstr(t["v"])}, {jstr(t["cur"])})'
+        if t["t"] == "dec":
+            return f'Runtime.dec({jstr(t["v"])})'
+        if t["t"] == "date":
+            return f'Runtime.date({jstr(t["v"])})'
+        if t["t"] == "enum":
+            return f'Runtime.sym({jstr(t["v"])})'
+        return jstr(t["v"])
+    if k == "bin":
+        return f'Runtime.{t["op"]}({term(t["l"])}, {term(t["r"])})'
+    if k == "call":
+        args = t["args"]
+        if t["fn"] == "round":
+            return f'Runtime.round({term(args[0])}, {term(args[1])}, {jstr(args[2]["v"])})'
+        return f'Runtime.{t["fn"]}(' + ", ".join(term(a) for a in args) + ')'
+    raise AssertionError(k)
+
+
+def emit(plan: dict) -> str:
+    check_plan(plan)
+    L = ["import java.util.ArrayList;", "import java.util.HashSet;", "import java.util.LinkedHashMap;",
+         "import java.util.List;", "import java.util.Map;", "import java.util.Set;", "",
+         "public final class Model {",
+         "    public static final Map<String, List<List<Object>>> TABLES = new LinkedHashMap<>();",
+         "    // Объявленные типы параметров: раннер сверяет с ними аргументы дела (§189).",
+         "    public static final Map<String, String[]> PARAMS = new LinkedHashMap<>();",
+         "    // Константы §54: тип для проверки §189 и значение для разыменования аргументов дела.",
+         "    public static final Map<String, Object[]> CONSTS = new LinkedHashMap<>();",
+         "    // Наследование сущностей: подтип подходит параметру базового типа.",
+         "    public static final Map<String, String> BASES = new LinkedHashMap<>();",
+         "    // Ключи отношений §45.1: позиции столбцов каждого ключа.",
+         "    public static final Map<String, int[][]> KEYS = new LinkedHashMap<>();",
+         "    public static final Map<String, String[]> KEY_READERS = new LinkedHashMap<>();",
+         "    private static final Set<String> SEEN = new HashSet<>();",
+         "",
+         "    static {"]
+    for t in plan["tables"]:
+        L.append(f'        TABLES.put({jstr(t["pred"])}, new ArrayList<>());')
+        L.append(f'        PARAMS.put({jstr(t["pred"])}, new String[]{{' + ", ".join(jstr(p) for p in t["params"]) + "});")
+    for t in plan["tables"]:
+        if t["keys"]:
+            L.append(f'        KEYS.put({jstr(t["pred"])}, new int[][]{{' + ", ".join("{" + ", ".join(str(i) for i in k) + "}" for k in t["keys"]) + "});")
+    for source, consumers in key_readers(plan).items():
+        L.append(f'        KEY_READERS.put({jstr(source)}, new String[]{{' + ", ".join(jstr(value) for value in consumers) + "});")
+    for cid, c in plan["consts"].items():
+        L.append(f'        CONSTS.put({jstr(cid)}, new Object[]{{{jstr(c["type"])}, {term(c["term"])}}});')
+    for sub, base in plan["bases"].items():
+        L.append(f'        BASES.put({jstr(sub)}, {jstr(base)});')
+    L.append("    }")
+    L.append("")
+    L.append("    // KEY_CONFLICT §45.1/§196: группы строк одной таблицы с одинаковой проекцией на ключ; строки уникальны по ключу строки, поэтому группа из двух и более строк — различные accepted-кортежи. Считается после насыщения.")
+    L.append("    static int keyConflicts() {")
+    L.append("        int n = 0;")
+    L.append("        for (Map.Entry<String, int[][]> e : KEYS.entrySet()) {")
+    L.append("            for (int[] key : e.getValue()) {")
+    L.append("                Map<String, Integer> groups = new LinkedHashMap<>();")
+    L.append("                for (List<Object> row : TABLES.get(e.getKey())) {")
+    L.append("                    List<Object> proj = new ArrayList<>();")
+    L.append("                    for (int i : key) proj.add(row.get(i));")
+    L.append("                    groups.merge(Runtime.key(proj), 1, Integer::sum);")
+    L.append("                }")
+    L.append("                for (int c : groups.values()) if (c > 1) n++;")
+    L.append("            }")
+    L.append("        }")
+    L.append("        return n;")
+    L.append("    }")
+    L.append("    static Set<String> keyConflictPredicates() {")
+    L.append("        Set<String> out = new HashSet<>();")
+    L.append("        for (Map.Entry<String, int[][]> e : KEYS.entrySet()) for (int[] key : e.getValue()) { Map<String, Integer> groups = new LinkedHashMap<>(); for (List<Object> row : TABLES.get(e.getKey())) { List<Object> proj = new ArrayList<>(); for (int i : key) proj.add(row.get(i)); groups.merge(Runtime.key(proj), 1, Integer::sum); } if (groups.values().stream().anyMatch(c -> c > 1)) out.add(e.getKey()); }")
+    L.append("        return out;")
+    L.append("    }")
+    L.append("")
+    L.append("    static boolean addRow(String urn, List<Object> row) {")
+    L.append('        String k = urn + "#" + Runtime.key(row);')
+    L.append("        if (!SEEN.add(k)) return false;")
+    L.append("        TABLES.get(urn).add(row);")
+    L.append("        return true;")
+    L.append("    }")
+    L.append("")
+    for r in plan["rules"]:
+        L.append(f'    // {r["id"]}')
+        L.append(f'    static boolean rule_{r["name"]}() {{')
+        L.append("        boolean grew = false;")
+        if r["window"]:
+            if r["window"].get("start"):
+                L.append(f'        if (Runtime.legalTime().compareTo({jstr(r["window"]["start"])}) < 0) return false;')
+            if r["window"].get("end"):
+                L.append(f'        if (Runtime.legalTime().compareTo({jstr(r["window"]["end"])}) >= 0) return false;')
+        ind = "        "
+        for i, a in enumerate(r["atoms"]):
+            L.append(f'{ind}for (List<Object> r{i} : new ArrayList<>(TABLES.get({jstr(a["pred"])}))) {{')
+            ind += "    "
+        for (ai, aj, _at), (bi, bj, _bt) in r["joins"]:
+            L.append(f'{ind}if (!Runtime.cmp(r{ai}.get({aj}), "eq", r{bi}.get({bj}))) continue;')
+        for f in r["filters"]:
+            L.append(f'{ind}if (!Runtime.eq(r{f["row"]}.get({f["col"]}), {term(f["term"])})) continue;')
+        for g in r["guards"]:
+            L.append(f'{ind}if (!Runtime.cmp({term(g["l"])}, "{g["op"]}", {term(g["r"])})) continue;')
+        args = ", ".join(term(a) for a in r["head"]["args"])
+        L.append(f'{ind}if (addRow({jstr(r["head"]["pred"])}, Runtime.row({args}))) grew = true;')
+        for _ in r["atoms"]:
+            ind = ind[:-4]
+            L.append(ind + "}")
+        L.append("        return grew;")
+        L.append("    }")
+        L.append("")
+    names = [r["name"] for r in plan["rules"]]
+    L.append("    static void saturate() {")
+    L.append("        boolean grew = true;")
+    L.append("        while (grew) {")
+    L.append("            grew = false;")
+    for n in names:
+        L.append(f"            if (rule_{n}()) grew = true;")
+    L.append("        }")
+    L.append("    }")
+    L.append("")
+    L.append("    static void register(String urn, List<Object> row) { addRow(urn, row); }")
+    L.append("")
+    L.append("    static void packageFacts() {")
+    for f in plan["facts"]:
+        L.append(f'        addRow({jstr(f["pred"])}, Runtime.row(' + ", ".join(term(a) for a in f["args"]) + "));")
+    L.append("    }")
+    L.append("}")
+    return "\n".join(L) + "\n"
+
+
+# --- дескриптор цели ---------------------------------------------------------
+HERE = Path(__file__).resolve().parent
+EXT = "java"
+MODEL = "Model.java"
+MAINS = {"runner": "Runner.java", "cert": "Cert.java"}
+
+
+def available():
+    javac, java = shutil.which("javac"), shutil.which("java")
+    return (True, javac) if javac and java else (False, "нет javac/java в PATH")
+
+
+def layout(proj, main: str) -> list:
+    proj = Path(proj)
+    proj.mkdir(parents=True, exist_ok=True)
+    out = []
+    for name in ("Runtime.java", "Json.java", MAINS[main]):
+        shutil.copyfile(HERE / name, proj / name)
+        out.append(proj / name)
+    return out
+
+
+def build(proj):
+    proj = Path(proj)
+    return ["javac", "-encoding", "UTF-8", "-d", "out"] + sorted(p.name for p in proj.glob("*.java")), str(proj)
+
+
+def run(proj, main: str):
+    return ["java", "-Dfile.encoding=UTF-8", "-cp", str(Path(proj) / "out"), MAINS[main][:-5]], None
+
+
+if __name__ == "__main__":
+    sys.path.insert(0, str(HERE.parents[1]))
+    import plan as P
+    ir = json.loads(Path(sys.argv[1]).read_text(encoding="utf-8"))
+    Path(sys.argv[2]).write_text(emit(P.build_plan(ir)), encoding="utf-8")

arxo_codegen/targets/kt/Cert.kt

@@ -0,0 +1,67 @@
+// Харнесс сертификации рантайма: исполняет runtime-cert.json и печатает,
+// что получилось. Ожидания сверяют ворота, харнесс их не читает.
+import java.io.File
+import java.math.BigInteger
+
+object Cert {
+    fun lit(x: Any?): Any? {
+        if (x is String) return x
+        val m = Json.obj(x)
+        if (m.containsKey("dec")) return RT.dec(Json.str(m["dec"]))
+        if (m.containsKey("money")) return RT.money(Json.str(m["money"]), Json.str(m["cur"]))
+        if (m.containsKey("text")) return Json.str(m["text"])
+        if (m.containsKey("date")) return RT.date(Json.str(m["date"]))
+        if (m.containsKey("sym")) return RT.sym(Json.str(m["sym"]))
+        if (m.containsKey("row")) return Json.arr(m["row"]).map { lit(it) }
+        throw IllegalArgumentException("литерал фикстуры: $x")
+    }
+
+    // Отображение с ЯВНЫМ масштабом: 2.00 и 2 — разные записи одного значения.
+    fun digits(u: BigInteger, s: Int): String {
+        val neg = u.signum() < 0
+        val body = u.abs().toString().padStart(s + 1, '0')
+        val text = if (s == 0) body else body.substring(0, body.length - s) + "." + body.substring(body.length - s)
+        return (if (neg) "-" else "") + text
+    }
+
+    fun render(v: Any?): Any? = when (v) {
+        null, is Boolean, is String -> v
+        is Money -> digits(v.u, v.s) + " " + v.cur
+        is Date -> v.v
+        is Sym -> v.id
+        is Dec -> digits(v.u, v.s)
+        else -> throw IllegalStateException("отображение: $v")
+    }
+
+    @Suppress("UNCHECKED_CAST")
+    fun run(c: Map<String, Any?>): Any? {
+        val a = Json.arr(c["args"]).map { lit(it) }
+        return when (Json.str(c["op"])) {
+            "dec" -> RT.dec(a[0] as String)
+            "money" -> RT.money(a[0] as String, a[1] as String)
+            "date" -> RT.date(a[0] as String)
+            "sym" -> RT.sym(a[0] as String)
+            "add" -> RT.add(a[0], a[1]); "sub" -> RT.sub(a[0], a[1]); "mul" -> RT.mul(a[0], a[1])
+            "div" -> RT.div(a[0], a[1]); "mod" -> RT.mod(a[0], a[1]); "min" -> RT.min(a[0], a[1])
+            "max" -> RT.max(a[0], a[1]); "abs" -> RT.abs(a[0]); "pow" -> RT.pow(a[0], a[1])
+            "round" -> RT.round(a[0], a[1], a[2] as String)
+            "cmp" -> RT.cmp(a[0], a[1] as String, a[2])
+            "eq" -> RT.eq(a[0], a[1])
+            "keyEq" -> RT.key(a[0] as List<Any?>) == RT.key(a[1] as List<Any?>)
+            "legalTime" -> RT.legalTime()
+            "setLegalTime" -> { RT.setLegalTime(a[0] as String); null }
+            else -> throw IllegalArgumentException("неизвестная операция фикстуры: " + c["op"])
+        }
+    }
+}
+
+fun main(argv: Array<String>) {
+    val fixture = Json.obj(Json.parse(File(argv[0]).readText()))
+    val out = ArrayList<Any?>()
+    for (c in Json.arr(fixture["cases"])) {
+        val cm = Json.obj(c)
+        val got: Any? = try { Cert.render(Cert.run(cm)) } catch (e: Refused) { linkedMapOf("refused" to e.message) }
+        out.add(linkedMapOf("id" to cm["id"], "got" to got))
+    }
+    println(Json.write(out))
+}

arxo_codegen/targets/kt/Json.kt

@@ -0,0 +1,103 @@
+// Минимальный JSON для раннера и харнесса: у Kotlin/JVM без зависимостей его
+// нет. Числа сохраняются ТЕКСТОМ (Num) — значение Integer дела не проходит
+// через Double. Объекты — LinkedHashMap в порядке документа.
+class Num(val text: String) { override fun toString() = text }
+
+class Json private constructor(private val s: String) {
+    private var i = 0
+
+    companion object {
+        fun parse(text: String): Any? {
+            val p = Json(text)
+            val v = p.value()
+            p.ws()
+            require(p.i == p.s.length) { "JSON: хвост после значения" }
+            return v
+        }
+
+        fun quote(t: String): String {
+            val b = StringBuilder("\"")
+            for (c in t) when (c) {
+                '"' -> b.append("\\\""); '\\' -> b.append("\\\\"); '\n' -> b.append("\\n")
+                '\r' -> b.append("\\r"); '\t' -> b.append("\\t")
+                else -> if (c < ' ') b.append(String.format("\\u%04x", c.code)) else b.append(c)
+            }
+            return b.append('"').toString()
+        }
+
+        @Suppress("UNCHECKED_CAST")
+        fun write(v: Any?): String = when (v) {
+            null -> "null"
+            is Boolean, is Num -> v.toString()
+            is String -> quote(v)
+            is List<*> -> v.joinToString(",", "[", "]") { write(it) }
+            is Map<*, *> -> (v as Map<String, Any?>).entries.joinToString(",", "{", "}") { quote(it.key) + ":" + write(it.value) }
+            else -> throw IllegalArgumentException("JSON: вид ${v::class}")
+        }
+
+        @Suppress("UNCHECKED_CAST")
+        fun obj(v: Any?): Map<String, Any?> = v as Map<String, Any?>
+        @Suppress("UNCHECKED_CAST")
+        fun arr(v: Any?): List<Any?> = (v as? List<Any?>) ?: emptyList()
+        fun str(v: Any?): String = v?.toString() ?: ""
+    }
+
+    private fun ws() { while (i < s.length && s[i] in " \t\r\n") i++ }
+
+    private fun value(): Any? {
+        ws()
+        val c = s[i]
+        if (c == '{') return obj()
+        if (c == '[') return arr()
+        if (c == '"') return string()
+        if (s.startsWith("true", i)) { i += 4; return true }
+        if (s.startsWith("false", i)) { i += 5; return false }
+        if (s.startsWith("null", i)) { i += 4; return null }
+        val start = i
+        while (i < s.length && s[i] in "+-0123456789.eE") i++
+        require(start != i) { "JSON: неожиданный символ $c" }
+        return Num(s.substring(start, i))
+    }
+
+    private fun obj(): Map<String, Any?> {
+        val m = LinkedHashMap<String, Any?>()
+        i++; ws()
+        if (s[i] == '}') { i++; return m }
+        while (true) {
+            ws(); val k = string(); ws()
+            require(s[i] == ':') { "JSON: ожидалось ':'" }; i++
+            m[k] = value(); ws()
+            val c = s[i++]
+            if (c == '}') return m
+            require(c == ',') { "JSON: ожидалась ','" }
+        }
+    }
+
+    private fun arr(): List<Any?> {
+        val a = ArrayList<Any?>()
+        i++; ws()
+        if (s[i] == ']') { i++; return a }
+        while (true) {
+            a.add(value()); ws()
+            val c = s[i++]
+            if (c == ']') return a
+            require(c == ',') { "JSON: ожидалась ','" }
+        }
+    }
+
+    private fun string(): String {
+        require(s[i] == '"') { "JSON: ожидалась строка" }; i++
+        val b = StringBuilder()
+        while (true) {
+            val c = s[i++]
+            if (c == '"') return b.toString()
+            if (c != '\\') { b.append(c); continue }
+            when (val e = s[i++]) {
+                '"' -> b.append('"'); '\\' -> b.append('\\'); '/' -> b.append('/'); 'b' -> b.append('\b')
+                'f' -> b.append(''); 'n' -> b.append('\n'); 'r' -> b.append('\r'); 't' -> b.append('\t')
+                'u' -> { b.append(s.substring(i, i + 4).toInt(16).toChar()); i += 4 }
+                else -> throw IllegalArgumentException("JSON: экран \\$e")
+            }
+        }
+    }
+}

arxo_codegen/targets/kt/Runner.kt

@@ -0,0 +1,126 @@
+// Раннер Kotlin-бэкенда: тот же вход и тот же ответ, что у runner.py.
+//
+// Протокол выхода общий для всех целей: ответ — JSON и код 0; названный отказ
+// среза — JSON {"refused": текст} и код 3; любой другой код — крах.
+import java.io.File
+import kotlin.system.exitProcess
+
+object Runner {
+    val ISSUES = ArrayList<Any?>()
+
+    fun arg(a: Map<String, Any?>): Any {
+        val kind = Json.str(a["kind"])
+        if (kind == "entity_ref") return Json.str(a["id"])
+        if (kind == "const_ref") {
+            // §54: разыменование предшествует исполнению; член перечисления §38 либо
+            // имя без объявления остаётся идентичностью, как в ключе атома оракула.
+            val c = Model.CONSTS[Json.str(a["id"])]
+            return if (c == null) RT.sym(Json.str(a["id"])) else c.second
+        }
+        if (kind != "value") throw Refused("аргумент вне среза раннера: $kind")
+        val t = Json.str(Json.obj(a["type"])["name"])
+        val v = Json.str(a["value"])
+        return when (t) {
+            "urn:law:std#Money" -> RT.money(v, Json.str(a["currency"]))
+            "urn:law:std#Decimal", "urn:law:std#Integer" -> RT.dec(v)
+            "urn:law:std#Text" -> v
+            "urn:law:std#Date" -> RT.date(v)
+            else -> throw Refused("аргумент вне среза раннера: $t")
+        }
+    }
+
+    // Тип аргумента, если известен: у value — из узла, у const_ref — из объявления
+    // константы; entity_ref типа не несёт (как у оракула).
+    fun argType(a: Map<String, Any?>): String? = when (Json.str(a["kind"])) {
+        "value" -> Json.str(Json.obj(a["type"])["name"])
+        "const_ref" -> Model.CONSTS[Json.str(a["id"])]?.first
+        else -> null
+    }
+
+    // Совпадение типа с наследованием сущностей вверх от фактического.
+    fun conforms(actual: String, expected: String): Boolean {
+        val seen = HashSet<String>()
+        var cur: String? = actual
+        while (cur != null && seen.add(cur)) {
+            if (cur == expected) return true
+            cur = Model.BASES[cur]
+        }
+        return false
+    }
+
+    fun args(lit: Map<String, Any?>) = Json.arr(lit["args"]).map { Json.obj(it) }
+
+    // Арность и типы аргументов утверждения против сигнатуры §189 (E-0046).
+    fun wellTyped(lit: Map<String, Any?>): Boolean {
+        val params = Model.PARAMS[Json.str(lit["predicate"])] ?: return true
+        val a = args(lit)
+        if (a.size != params.size) { ISSUES.add("TYPE_ERROR"); return false }
+        for (i in params.indices) {
+            val actual = argType(a[i])
+            if (actual != null && !conforms(actual, params[i])) { ISSUES.add("TYPE_ERROR"); return false }
+        }
+        return true
+    }
+
+    // Ключ атома у оракула §208 включает ТИП значения: несогласованный запрос
+    // атома не находит — NEITHER без issue.
+    fun queryTyped(lit: Map<String, Any?>): Boolean {
+        val params = Model.PARAMS[Json.str(lit["predicate"])] ?: return false
+        val a = args(lit)
+        if (a.size != params.size) return false
+        return params.indices.all { i -> val t = argType(a[i]); t == null || conforms(t, params[i]) }
+    }
+
+    fun keyConflictBlocks(predicate: String): Boolean {
+        val tainted = Model.keyConflictPredicates()
+        val waiting = ArrayList(tainted)
+        while (waiting.isNotEmpty()) {
+            val source = waiting.removeAt(waiting.lastIndex)
+            for (consumer in Model.KEY_READERS[source] ?: emptyList()) if (tainted.add(consumer)) waiting.add(consumer)
+        }
+        return predicate in tainted
+    }
+
+    fun run(casePath: String, queryPath: String) {
+        val kase = Json.obj(Json.parse(File(casePath).readText()))
+        val query = Json.obj(Json.parse(File(queryPath).readText()))
+        val ctx = if (kase["context"] == null) emptyMap() else Json.obj(kase["context"])
+        RT.setLegalTime(Json.str(ctx["legalTime"]))
+        Model.packageFacts()
+        for (a in Json.arr(kase["assertions"])) {
+            val lit = Json.obj(Json.obj(a)["literal"])
+            if (Json.str(lit["polarity"]) != "positive") throw Refused("§113: отрицательный факт вне L0-среза")
+            if (!wellTyped(lit)) continue
+            val pred = Json.str(lit["predicate"])
+            if (!Model.PARAMS.containsKey(pred)) continue
+            Model.register(pred, args(lit).map { arg(it) })
+        }
+        Model.saturate()
+        repeat(Model.keyConflicts()) { ISSUES.add("KEY_CONFLICT") }
+        if (Json.str(query["kind"]) != "truth") throw Refused("вид запроса вне среза раннера: " + Json.str(query["kind"]))
+        val lit = Json.obj(query["literal"])
+        var hit = false
+        if (queryTyped(lit)) {
+            val want = args(lit).map { arg(it) }
+            val rows = Model.TABLES[Json.str(lit["predicate"])] ?: emptyList()
+            hit = rows.any { r -> r.size == want.size && r.indices.all { RT.eq(r[it], want[it]) } }
+        }
+        // Открытый мир: отсутствие строки — это NEITHER, а не FALSE_ONLY.
+        val out = linkedMapOf<String, Any?>(
+            "queryId" to query["queryId"],
+            "truthStatus" to (if (hit) "TRUE_ONLY" else "NEITHER"),
+            "evaluationStatus" to (if (keyConflictBlocks(Json.str(lit["predicate"]))) "NON_EXECUTABLE" else "COMPUTED"),
+            "issues" to ISSUES,
+        )
+        println(Json.write(out))
+    }
+}
+
+fun main(argv: Array<String>) {
+    try {
+        Runner.run(argv[0], argv[1])
+    } catch (e: Refused) {
+        println(Json.write(linkedMapOf("refused" to e.message)))
+        exitProcess(3)
+    }
+}