browser-py 0.1.0__py3-none-any.whl

browser_source.py

@@ -0,0 +1,598 @@
+from ast import (
+   AST,
+   Add,
+   And,
+   AnnAssign,
+   Assign,
+   AsyncFunctionDef,
+   Attribute,
+   AugAssign,
+   Await,
+   BinOp,
+   BitAnd,
+   BitOr,
+   BitXor,
+   BoolOp,
+   Break,
+   Call,
+   ClassDef,
+   Compare,
+   Constant,
+   Continue,
+   Dict,
+   Div,
+   Eq,
+   ExceptHandler,
+   Expr,
+   For,
+   FunctionDef,
+   Gt,
+   GtE,
+   If,
+   IfExp,
+   ImportFrom,
+   Is,
+   IsNot,
+   List,
+   Lt,
+   LtE,
+   Mult,
+   Name,
+   Not,
+   NotEq,
+   Pass,
+   Raise,
+   Return,
+   Store,
+   Sub,
+   Subscript,
+   Try,
+   Tuple,
+   UAdd,
+   UnaryOp,
+   USub,
+   While,
+   expr,
+   parse,
+   stmt,
+   walk,
+)
+from dataclasses import dataclass
+from json import dumps
+from pathlib import Path
+
+from numeric_source import require_acyclic
+
+
+@dataclass
+class Emission:
+   node: stmt | None
+   text: str
+   depth: int
+   exception: str
+
+
+@dataclass
+class BrowserScope:
+   names: set[str]
+   arities: dict[str, int]
+   constructors: set[str]
+   arrays: set[str]
+   native: set[str]
+   asynchronous: bool
+
+
+def annotation_shape(node: expr | None, constructors: set[str]) -> str:
+   if node is None:
+      return "native"
+   if isinstance(node, Constant) and node.value is None:
+      return "void"
+   if isinstance(node, Name):
+      if node.id in ("int", "float", "str", "bool"):
+         return "value"
+      if node.id in constructors:
+         return "record"
+   if isinstance(node, Subscript) and isinstance(node.value, Name):
+      element = node.slice
+      if node.value.id == "tuple" and isinstance(element, Tuple) and len(element.elts) == 2:
+         if isinstance(element.elts[1], Constant) and element.elts[1].value is Ellipsis:
+            element = element.elts[0]
+         else:
+            raise NotImplementedError("Browser tuple annotations require one repeated element type")
+      if node.value.id in ("list", "tuple") and isinstance(element, Name):
+         if element.id in ("int", "float", "str", "bool") or element.id in constructors:
+            return "array"
+   raise NotImplementedError("Unsupported browser annotation")
+
+
+def operator_text(node: BinOp | AugAssign | Compare | UnaryOp) -> str:
+   operator = node.ops[0] if isinstance(node, Compare) else node.op
+   if isinstance(operator, Add):
+      return "+"
+   if isinstance(operator, Sub):
+      return "-"
+   if isinstance(operator, Mult):
+      return "*"
+   if isinstance(operator, Div):
+      return "/"
+   if isinstance(operator, BitAnd):
+      return "&"
+   if isinstance(operator, BitOr):
+      return "|"
+   if isinstance(operator, BitXor):
+      return "^"
+   if isinstance(operator, (Eq, Is)):
+      return "==="
+   if isinstance(operator, (NotEq, IsNot)):
+      return "!=="
+   if isinstance(operator, Lt):
+      return "<"
+   if isinstance(operator, LtE):
+      return "<="
+   if isinstance(operator, Gt):
+      return ">"
+   if isinstance(operator, GtE):
+      return ">="
+   if isinstance(operator, Not):
+      return "!"
+   if isinstance(operator, USub):
+      return "-"
+   if isinstance(operator, UAdd):
+      return "+"
+   raise NotImplementedError("Unsupported browser operator: " + type(operator).__name__)
+
+
+def expression_text(value: expr, scope: BrowserScope) -> str:
+   text: dict[expr, str] = {}
+   shapes: dict[expr, str] = {}
+   nodes = list(walk(value))
+   targets = {item.func for item in nodes if isinstance(item, Call)}
+   for node in reversed(nodes):
+      if not isinstance(node, expr):
+         continue
+      shape = "value"
+      if isinstance(node, Constant):
+         if node.value is None or isinstance(node.value, (str, bool, int, float)):
+            result = dumps(node.value, ensure_ascii=True, allow_nan=False)
+         else:
+            raise NotImplementedError("Unsupported browser literal")
+      elif isinstance(node, Name):
+         if node.id in scope.names:
+            result = node.id if node.id in ("window", "document") else "p_" + node.id
+            if node.id in scope.arrays:
+               shape = "array"
+            elif node.id in scope.native:
+               shape = "native"
+         elif node.id in ("len", "int", "str", "ValueError") and node in targets:
+            result = node.id
+         else:
+            raise NotImplementedError("Unknown browser name: " + node.id)
+         if node.id in scope.arities and node not in targets:
+            raise NotImplementedError("Browser functions must be called directly")
+      elif isinstance(node, (List, Tuple)):
+         result = "[" + ", ".join(text[item] for item in node.elts) + "]"
+         shape = "array"
+      elif isinstance(node, Dict):
+         fields = []
+         for i in range(len(node.keys)):
+            key = node.keys[i]
+            if isinstance(key, Constant) and isinstance(key.value, str):
+               fields.append(text[key] + ": " + text[node.values[i]])
+            else:
+               raise NotImplementedError("Browser descriptors require literal string keys")
+         result = "({" + ", ".join(fields) + "})"
+         shape = "native"
+      elif isinstance(node, Attribute):
+         if node.attr.startswith("_") and node.attr != "__new__":
+            raise NotImplementedError("Private browser attributes are unsupported")
+         if node.attr == "append":
+            if shapes[node.value] == "array" and node in targets:
+               result = text[node.value] + ".push"
+            else:
+               raise NotImplementedError("append requires a known array and a direct call")
+         else:
+            result = "(" + text[node.value] + ")." + node.attr
+         shape = "native"
+      elif isinstance(node, Subscript):
+         result = "(" + text[node.value] + ")[" + text[node.slice] + "]"
+         shape = "native"
+      elif isinstance(node, BinOp):
+         if shapes[node.left] == "array" or shapes[node.right] == "array":
+            raise NotImplementedError("Browser arrays do not support arithmetic")
+         result = "(" + text[node.left] + " " + operator_text(node) + " " + text[node.right] + ")"
+      elif isinstance(node, UnaryOp):
+         result = "(" + operator_text(node) + text[node.operand] + ")"
+      elif isinstance(node, BoolOp):
+         symbol = " && " if isinstance(node.op, And) else " || "
+         result = "(" + symbol.join(text[item] for item in node.values) + ")"
+      elif isinstance(node, Compare) and len(node.ops) == 1:
+         result = "(" + text[node.left] + " " + operator_text(node) + " " + text[node.comparators[0]] + ")"
+      elif isinstance(node, IfExp):
+         result = "(" + text[node.test] + " ? " + text[node.body] + " : " + text[node.orelse] + ")"
+         if shapes[node.body] == shapes[node.orelse]:
+            shape = shapes[node.body]
+      elif isinstance(node, Await) and scope.asynchronous:
+         result = "(await " + text[node.value] + ")"
+         shape = "native"
+      elif isinstance(node, Call):
+         if node.keywords:
+            raise NotImplementedError("Browser calls require positional arguments")
+         args = ", ".join(text[item] for item in node.args)
+         if isinstance(node.func, Name):
+            name = node.func.id
+            if name in ("len", "int", "str", "ValueError") and len(node.args) == 1:
+               if name == "len":
+                  result = "(" + args + ").length"
+               elif name == "int":
+                  result = "Math.trunc(" + args + ")"
+               elif name == "str":
+                  result = "String(" + args + ")"
+               else:
+                  result = "new Error(" + args + ")"
+            elif name in scope.arities and len(node.args) == scope.arities[name]:
+               prefix = "new " if name in scope.constructors else ""
+               result = prefix + text[node.func] + "(" + args + ")"
+               if name in scope.arrays:
+                  shape = "array"
+               elif name in scope.native:
+                  shape = "native"
+            else:
+               raise NotImplementedError("Unsupported browser call or arity: " + name)
+         elif isinstance(node.func, Attribute) and node.func.attr == "__new__":
+            if shapes[node.func.value] == "native":
+               result = "new (" + text[node.func.value] + ")(" + args + ")"
+               shape = "native"
+            else:
+               raise NotImplementedError("Native constructor required")
+         elif isinstance(node.func, (Attribute, Subscript)):
+            result = text[node.func] + "(" + args + ")"
+            shape = "native"
+         else:
+            raise NotImplementedError("Browser call must name a function or native method")
+      else:
+         raise NotImplementedError("Unsupported browser expression: " + type(node).__name__)
+      text[node] = result
+      shapes[node] = shape
+   return text[value]
+
+
+def emit_statements(body: list[stmt], scope: BrowserScope) -> str:
+   stack = [Emission(node, "", 0, "") for node in reversed(body)]
+   lines = []
+   serial = 0
+   while stack:
+      task = stack.pop()
+      node = task.node
+      depth = task.depth
+      exception = task.exception
+      if node is None:
+         lines.append("   " * depth + task.text)
+         continue
+      text = ""
+      if isinstance(node, (Assign, AnnAssign)):
+         target = node.targets[0] if isinstance(node, Assign) and len(node.targets) == 1 else None
+         if isinstance(node, AnnAssign):
+            target = node.target
+         if isinstance(target, (Name, Attribute, Subscript)) and node.value is not None:
+            text = expression_text(target, scope) + " = " + expression_text(node.value, scope) + ";"
+         else:
+            raise NotImplementedError("Browser assignments require one explicit target/value")
+      elif isinstance(node, AugAssign) and isinstance(node.target, (Name, Attribute, Subscript)):
+         text = (
+            expression_text(node.target, scope)
+            + " "
+            + operator_text(node)
+            + "= "
+            + expression_text(node.value, scope)
+            + ";"
+         )
+      elif isinstance(node, Expr):
+         if isinstance(node.value, Constant) and isinstance(node.value.value, str):
+            continue
+         if isinstance(node.value, (Call, Await)):
+            text = expression_text(node.value, scope) + ";"
+         else:
+            raise NotImplementedError("Browser expression statements must be calls")
+      elif isinstance(node, Return):
+         text = (
+            "return " + (expression_text(node.value, scope) if node.value is not None else "undefined") + ";"
+         )
+      elif isinstance(node, Raise):
+         if node.cause is not None:
+            raise NotImplementedError("Browser exception causes are unsupported")
+         if node.exc is not None:
+            text = "throw " + expression_text(node.exc, scope) + ";"
+         elif exception:
+            text = "throw " + exception + ";"
+         else:
+            raise NotImplementedError("Bare raise requires a catch scope")
+      elif isinstance(node, If):
+         text = "if (" + expression_text(node.test, scope) + ") {"
+         stack.append(Emission(None, "}", depth, exception))
+         if node.orelse:
+            stack.extend(Emission(item, "", depth + 1, exception) for item in reversed(node.orelse))
+            stack.append(Emission(None, "} else {", depth, exception))
+         stack.extend(Emission(item, "", depth + 1, exception) for item in reversed(node.body))
+      elif isinstance(node, (For, While)):
+         if node.orelse:
+            raise NotImplementedError("Browser loop else clauses are unsupported")
+         if isinstance(node, While):
+            text = "while (" + expression_text(node.test, scope) + ") {"
+         elif isinstance(node.target, Name):
+            variable = expression_text(node.target, scope)
+            iterator = node.iter
+            if isinstance(iterator, Call) and isinstance(iterator.func, Name) and iterator.func.id == "range":
+               if iterator.keywords or len(iterator.args) not in (1, 2, 3):
+                  raise NotImplementedError("Expected range with one to three positional arguments")
+               args = [expression_text(item, scope) for item in iterator.args]
+               start = args[0] if len(args) > 1 else "0"
+               stop = args[1] if len(args) > 1 else args[0]
+               step = args[2] if len(args) == 3 else "1"
+               if len(args) == 3 and not (
+                  isinstance(iterator.args[2], Constant)
+                  and type(iterator.args[2].value) is int
+                  and iterator.args[2].value > 0
+               ):
+                  raise NotImplementedError("Browser ranges require a positive literal step")
+               serial += 1
+               initial = "bp_start_" + str(serial)
+               limit = "bp_limit_" + str(serial)
+               index = "bp_index_" + str(serial)
+               lines.append("   " * depth + "const " + initial + " = " + start + ";")
+               lines.append("   " * depth + "const " + limit + " = " + stop + ";")
+               text = f"for (let {index} = {initial}; {index} < {limit}; {index} += {step}) {{"
+               stack.append(Emission(None, "}", depth, exception))
+               stack.extend(Emission(item, "", depth + 1, exception) for item in reversed(node.body))
+               stack.append(Emission(None, variable + " = " + index + ";", depth + 1, exception))
+               lines.append("   " * depth + text)
+               continue
+            elif isinstance(iterator, (List, Tuple)) or (
+               isinstance(iterator, Name) and iterator.id in scope.arrays
+            ):
+               text = "for (" + variable + " of " + expression_text(iterator, scope) + ") {"
+            else:
+               raise NotImplementedError("Browser iteration requires range or a known array")
+         else:
+            raise NotImplementedError("Browser loops require a single named target")
+         stack.append(Emission(None, "}", depth, exception))
+         stack.extend(Emission(item, "", depth + 1, exception) for item in reversed(node.body))
+      elif isinstance(node, Try):
+         if node.orelse or len(node.handlers) > 1:
+            raise NotImplementedError("Browser try supports one native catch and/or finally")
+         text = "try {"
+         stack.append(Emission(None, "}", depth, exception))
+         if node.finalbody:
+            stack.extend(Emission(item, "", depth + 1, exception) for item in reversed(node.finalbody))
+            stack.append(Emission(None, "} finally {", depth, exception))
+         if node.handlers:
+            handler = node.handlers[0]
+            if handler.type is not None and not (
+               isinstance(handler.type, Name) and handler.type.id == "Exception"
+            ):
+               raise NotImplementedError(
+                  "Browser catches handle native exceptions without Python type dispatch"
+               )
+            serial += 1
+            caught = "bp_error_" + str(serial)
+            stack.extend(Emission(item, "", depth + 1, caught) for item in reversed(handler.body))
+            if handler.name is not None:
+               stack.append(
+                  Emission(None, "const p_" + handler.name + " = " + caught + ";", depth + 1, caught)
+               )
+            stack.append(Emission(None, "} catch (" + caught + ") {", depth, caught))
+         stack.extend(Emission(item, "", depth + 1, exception) for item in reversed(node.body))
+      elif isinstance(node, Pass):
+         continue
+      elif isinstance(node, Break):
+         text = "break;"
+      elif isinstance(node, Continue):
+         text = "continue;"
+      else:
+         raise NotImplementedError("Unsupported browser statement: " + type(node).__name__)
+      lines.append("   " * depth + text)
+   return "\n".join(lines)
+
+
+def compile_browser_source(source: Path) -> str:
+   tree = parse(source.read_text())
+   names = set()
+   arities: dict[str, int] = {}
+   constructors = set()
+   arrays = set()
+   native = {"window", "document"}
+   functions: list[FunctionDef | AsyncFunctionDef] = []
+   lines = []
+   exports = []
+   entry: list[stmt] = []
+   dataclass_imported = False
+   imports_open = True
+   model_names = {item.name for item in tree.body if isinstance(item, ClassDef)}
+   for node in tree.body:
+      if isinstance(node, Expr) and isinstance(node.value, Constant) and isinstance(node.value.value, str):
+         continue
+      if isinstance(node, ImportFrom) and imports_open:
+         if node.level or node.module is None or not node.module.isidentifier():
+            raise NotImplementedError("Browser imports require direct module names")
+         symbols = [item.name for item in node.names]
+         if any(
+            item.asname is not None
+            or item.name == "*"
+            or item.name in names
+            or item.name in ("len", "str", "int", "range", "ValueError")
+            for item in node.names
+         ):
+            raise NotImplementedError("Browser imports require unique unaliased symbols")
+         names.update(symbols)
+         if node.module == "browser":
+            if set(symbols) <= {"window", "document"}:
+               continue
+            raise NotImplementedError("Browser imports expose only native document and window")
+         if node.module == "dataclasses":
+            if symbols == ["dataclass"]:
+               dataclass_imported = True
+               continue
+            raise NotImplementedError("Browser dataclass imports expose only the decorator")
+         if node.module.startswith("__"):
+            raise NotImplementedError("Browser entry modules cannot be imported")
+         target = source.parent / (node.module + ".py")
+         if not target.is_file():
+            raise NotImplementedError("Browser imports must name local source modules: " + node.module)
+         definitions = {
+            item.name: item for item in parse(target.read_text()).body if isinstance(item, FunctionDef)
+         }
+         for symbol in symbols:
+            if symbol not in definitions:
+               raise NotImplementedError("Browser imports must name directly defined functions: " + symbol)
+            definition = definitions[symbol]
+            arities[symbol] = len(definition.args.args)
+            shape = annotation_shape(definition.returns, set())
+            if shape == "array":
+               arrays.add(symbol)
+            elif shape == "native":
+               native.add(symbol)
+         bindings = ", ".join(symbol + " as p_" + symbol for symbol in symbols)
+         lines.append("import { " + bindings + " } from './" + node.module + ".js';")
+         continue
+      imports_open = False
+      if isinstance(node, (FunctionDef, AsyncFunctionDef, ClassDef)):
+         if (
+            node.name in names
+            or node.name in native
+            or node.name in ("len", "str", "int", "range", "ValueError")
+         ):
+            raise NotImplementedError("Duplicate/reserved browser name: " + node.name)
+         names.add(node.name)
+         exports.append("p_" + node.name + " as " + node.name)
+      if isinstance(node, (FunctionDef, AsyncFunctionDef)):
+         args = node.args
+         if (
+            node.decorator_list
+            or node.type_params
+            or args.defaults
+            or args.kw_defaults
+            or args.vararg
+            or args.kwarg
+            or args.kwonlyargs
+            or args.posonlyargs
+         ):
+            raise NotImplementedError("Browser functions require plain positional parameters")
+         arities[node.name] = len(args.args)
+         for parameter in args.args:
+            annotation_shape(parameter.annotation, model_names)
+         shape = annotation_shape(node.returns, model_names)
+         if shape == "array":
+            arrays.add(node.name)
+         elif shape == "native":
+            native.add(node.name)
+         functions.append(node)
+      elif isinstance(node, ClassDef):
+         if not (
+            dataclass_imported
+            and len(node.decorator_list) == 1
+            and isinstance(node.decorator_list[0], Name)
+            and node.decorator_list[0].id == "dataclass"
+            and not node.bases
+            and not node.keywords
+            and not node.type_params
+         ):
+            raise NotImplementedError("Browser classes must be plain required-field dataclasses")
+         fields = []
+         for field in node.body:
+            if isinstance(field, AnnAssign) and isinstance(field.target, Name) and field.value is None:
+               if field.target.id in fields:
+                  raise NotImplementedError("Duplicate browser dataclass field")
+               if annotation_shape(field.annotation, model_names) in ("value", "record", "array"):
+                  fields.append(field.target.id)
+               else:
+                  raise NotImplementedError("Browser dataclass fields require explicit value annotations")
+            else:
+               raise NotImplementedError("Browser dataclasses require annotation-only fields")
+         constructors.add(node.name)
+         arities[node.name] = len(fields)
+         lines.append(
+            "class p_" + node.name + " {\nconstructor(" + ", ".join("p_" + item for item in fields) + ") {"
+         )
+         for field_name in fields:
+            lines.append("this." + field_name + " = p_" + field_name + ";")
+         lines.append("}\n}")
+      elif isinstance(node, (Expr, Try)):
+         entry.append(node)
+      else:
+         raise NotImplementedError("Browser module scope permits imports, definitions, and entry calls only")
+   calls = {}
+   function_names = {item.name for item in functions}
+   for function in functions:
+      calls[function.name] = {
+         item.func.id
+         for statement in function.body
+         for item in walk(statement)
+         if isinstance(item, Call) and isinstance(item.func, Name) and item.func.id in function_names
+      }
+   require_acyclic(calls, "Browser calls")
+   for function in functions:
+      parameters = {item.arg for item in function.args.args}
+      if len(parameters) != len(function.args.args):
+         raise NotImplementedError("Browser parameters must have unique names")
+      locals_ = set(parameters)
+      local_arrays = set(arrays)
+      local_native = set(native)
+      nodes: list[AST] = []
+      for parameter in function.args.args:
+         shape = annotation_shape(parameter.annotation, model_names)
+         if shape == "array":
+            local_arrays.add(parameter.arg)
+         elif shape == "native":
+            local_native.add(parameter.arg)
+      for statement in function.body:
+         nodes.extend(walk(statement))
+      for item in nodes:
+         if isinstance(item, (FunctionDef, AsyncFunctionDef, ClassDef, ImportFrom)):
+            raise NotImplementedError("Browser functions cannot contain nested definitions/imports")
+         if isinstance(item, Name) and isinstance(item.ctx, Store):
+            locals_.add(item.id)
+         if isinstance(item, AnnAssign):
+            annotation_shape(item.annotation, model_names)
+         if isinstance(item, ExceptHandler) and item.name is not None:
+            locals_.add(item.name)
+         if isinstance(item, Assign) and len(item.targets) == 1 and isinstance(item.targets[0], Name):
+            if isinstance(item.value, (List, Tuple)) or (
+               isinstance(item.value, IfExp)
+               and isinstance(item.value.body, (List, Tuple))
+               and isinstance(item.value.orelse, (List, Tuple))
+            ):
+               local_arrays.add(item.targets[0].id)
+            else:
+               local_native.add(item.targets[0].id)
+      if locals_ & (set(arities) | {"window", "document", "len", "str", "int", "range", "ValueError"}):
+         raise NotImplementedError("Browser locals cannot shadow callables or native globals")
+      scope = BrowserScope(
+         names | locals_,
+         arities,
+         constructors,
+         local_arrays,
+         local_native,
+         isinstance(function, AsyncFunctionDef),
+      )
+      declaration = "async function " if scope.asynchronous else "function "
+      signature = ", ".join("p_" + item.arg for item in function.args.args)
+      lines.append(declaration + "p_" + function.name + "(" + signature + ") {")
+      declared = sorted(locals_ - parameters)
+      if declared:
+         lines.append("let " + ", ".join("p_" + item for item in declared) + ";")
+      lines.append(emit_statements(function.body, scope))
+      lines.append("}")
+   if entry:
+      for statement in entry:
+         for item in walk(statement):
+            if isinstance(item, Name) and isinstance(item.ctx, Store):
+               raise NotImplementedError("Browser entry state belongs inside a function")
+      caught_names = {
+         item.name
+         for statement in entry
+         for item in walk(statement)
+         if isinstance(item, ExceptHandler) and item.name is not None
+      }
+      scope = BrowserScope(names | caught_names, arities, constructors, arrays, native, True)
+      lines.append(emit_statements(entry, scope))
+   lines.append("export { " + ", ".join(exports) + " };\n")
+   return "\n".join(lines)

compiler_command.py

@@ -0,0 +1,53 @@
+from argparse import ArgumentParser
+from os import environ
+from pathlib import Path
+from subprocess import run
+from sys import executable
+from tempfile import mkdtemp
+
+from browser_compile import compile_modules
+
+
+def main() -> None:
+   parser = ArgumentParser(prog="browser-py", description="Compile Python for the browser")
+   commands = parser.add_subparsers(dest="command", required=True)
+   compile_command = commands.add_parser(
+      "compile", help="Compile a typed numeric Python module and its imports"
+   )
+   compile_command.add_argument("source", type=Path)
+   compile_command.add_argument(
+      "--unminified", action="store_true", help="Keep generated modules uncompressed"
+   )
+   compile_command.add_argument("--output", type=Path, help="Write compiled files to this directory")
+   commands.add_parser("validate", help="Run synchronous regression checks from a source checkout")
+   args = parser.parse_args()
+   root = Path(__file__).resolve().parents[1]
+   if args.command == "compile":
+      output = args.output
+      if output is None:
+         output = Path(mkdtemp(prefix="browser-py-compile-", dir="/tmp"))
+      entry = compile_modules(args.source, output, not args.unminified)
+      print(f"Compiled {entry}", flush=True)
+      print("Orchestration: command -> source admission -> mypyc IR -> browser-py emission -> ES modules")
+      return
+   if args.command == "validate":
+      if not (root / "pyproject.toml").is_file() or not (root / "tests").is_dir():
+         parser.error("validate requires a source checkout; run python -B browser_py.py validate there")
+      environment = {**environ, "PYTHONPATH": str(root / "source"), "PYTHONDONTWRITEBYTECODE": "1"}
+      run(
+         [executable, "-B", "-m", "ruff", "check", str(root / "source"), str(root / "tests")],
+         env=environment,
+         check=True,
+      )
+      run(
+         [executable, "-B", "-m", "ruff", "format", "--check", str(root / "source"), str(root / "tests")],
+         env=environment,
+         check=True,
+      )
+      run(
+         [executable, "-B", "-m", "mypy", str(root / "source"), str(root / "tests")],
+         env=environment,
+         check=True,
+      )
+      run([executable, "-B", "-m", "pytest", str(root / "tests")], env=environment, check=True)
+      print("Orchestration: command -> Ruff -> mypy -> regression tests")

javascript_output.py

@@ -0,0 +1,9 @@
+from pathlib import Path
+
+from rjsmin import jsmin
+
+
+def write_javascript(javascript: str, target: Path, minified: bool) -> None:
+   if minified:
+      javascript = jsmin(javascript)
+   target.write_text(javascript)