imandrax-codegen 18.1.1__py3-none-any.whl

imandrax_codegen/__main__.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python
+import sys
+from pathlib import Path
+
+import typer
+from imandrax_codegen.test_gen import gen_test_cases
+from imandrax_codegen.unparse import unparse
+
+app = typer.Typer()
+
+
+@app.command()
+def main(
+    iml_path: str = typer.Argument(
+        help='Path of IML file to generate test cases (use "-" to read from stdin)',
+    ),
+    function: str = typer.Option(
+        ...,
+        '-f',
+        '--function',
+        help='Name of function to generate test cases for',
+    ),
+    output: str | None = typer.Option(
+        None,
+        '-o',
+        '--output',
+        help='Output file path (defaults to stdout)',
+    ),
+) -> None:
+    """Generate test cases for IML."""
+    # Read input from stdin or file
+    if iml_path == '-':
+        iml = sys.stdin.read()
+    else:
+        iml = Path(iml_path).read_text()
+
+    test_case_stmts = gen_test_cases(iml, function)
+    result = unparse(test_case_stmts)
+
+    # Write output to file or stdout
+    if output:
+        Path(output).write_text(result)
+    else:
+        typer.echo(result)
+
+
+if __name__ == '__main__':
+    app()

imandrax_codegen/art_parse.py

@@ -0,0 +1,115 @@
+import base64
+import json
+import subprocess
+import sys
+from functools import singledispatch
+from pathlib import Path
+from typing import Literal
+
+import imandrax_codegen.ast_types as ast_types
+from imandrax_api import url_dev, url_prod  # noqa: F401
+from imandrax_api_models import Art
+from imandrax_codegen.ast_deserialize import stmts_of_json
+
+
+def find_art_parse_exe() -> Path:
+    """Find the art_parse executable.
+
+    Raises:
+        RuntimeError: If the executable is not found (unsupported platform)
+    """
+    exe_path = Path(__file__).parent / 'art_parse.exe'
+
+    if sys.platform != 'darwin':
+        raise ValueError(
+            'Only MacOS is supported for now. Please wait for the next release.'
+        )
+
+    if not exe_path.exists():
+        raise ValueError(
+            f'art_parse.exe not found in {exe_path.parent}. '
+            f'The package might not be built correctly.'
+        )
+    return exe_path
+
+
+CODEGEN_EXE_PATH = find_art_parse_exe()
+
+
+def _convert_to_standard_base64(data: str | bytes) -> str:
+    """Convert bytes or URL-safe base64 string to standard base64.
+
+    Handles two cases:
+    1. If data is bytes: directly encode to standard base64
+    2. If data is a URL-safe base64 string: convert to standard base64
+
+    Pydantic serializes bytes as URL-safe base64 (using - and _ instead of + and /),
+    but OCaml's Base64.decode_exn expects standard base64 encoding.
+
+    Args:
+        data: Either raw bytes or URL-safe base64 string
+
+    Returns:
+        Standard base64 string
+    """
+    if isinstance(data, bytes):
+        # Directly encode bytes to standard base64
+        return base64.b64encode(data).decode('ascii')
+
+    # It's a string - assume it's URL-safe base64
+    # Add padding if needed
+    padding = (4 - len(data) % 4) % 4
+    urlsafe_b64_padded = data + ('=' * padding)
+
+    # Decode URL-safe and re-encode as standard base64
+    decoded_bytes = base64.urlsafe_b64decode(urlsafe_b64_padded)
+    return base64.b64encode(decoded_bytes).decode('ascii')
+
+
+def _serialize_artifact(art: Art) -> str:
+    """Serialize an artifact BaseModel to a JSON string."""
+    art_dict = art.model_dump()
+    art_dict['data'] = _convert_to_standard_base64(art_dict['data'])
+    return json.dumps(art_dict)
+
+
+@singledispatch
+def ast_of_art(
+    art: str | Art, mode: Literal['fun-decomp', 'model', 'decl']
+) -> list[ast_types.stmt]:
+    raise NotImplementedError(f'Only Art and str are supported, got {type(art)}')
+
+
+@ast_of_art.register
+def _(
+    art: str,
+    mode: Literal['fun-decomp', 'model', 'decl'],
+) -> list[ast_types.stmt]:
+    """Use the codegen executable to generate ASTs for a given artifact."""
+    result = subprocess.run(
+        [
+            CODEGEN_EXE_PATH,
+            '-',
+            '-',
+            '--mode',
+            mode,
+        ],
+        check=False,
+        input=art,
+        text=True,
+        capture_output=True,
+    )
+    if result.returncode != 0:
+        raise RuntimeError(f'Failed to run generate AST: {result.stderr}')
+    return stmts_of_json(result.stdout)
+
+
+@ast_of_art.register
+def _(
+    art: Art,
+    mode: Literal['fun-decomp', 'model', 'decl'],
+) -> list[ast_types.stmt]:
+    return ast_of_art(_serialize_artifact(art), mode)
+
+
+# END [[ast_of_art]]>

imandrax_codegen/ast_deserialize.py

@@ -0,0 +1,102 @@
+"""Simple recursive deserializer for OCaml yojson AST format.
+
+OCaml format: ["Tag", {...}] for variants with fields, ["Tag"] for empty
+variants.
+Location info is NOT deserialized - use ast.fix to add it later.
+"""
+
+from __future__ import annotations
+
+from typing import Any, cast
+
+from . import ast_types as ast
+
+
+def deserialize_constant_value(value: Any) -> Any:
+    """Deserialize constant value from OCaml tagged format."""
+    if not isinstance(value, list):
+        return value
+
+    value_list = cast(list[Any], value)
+    if len(value_list) < 1 or not isinstance(value_list[0], str):
+        return cast(Any, value)
+
+    tag: str = value_list[0]
+    if tag == 'Unit':
+        return None
+    elif tag in ('String', 'Bytes', 'Bool', 'Int', 'Float'):
+        return value_list[1]
+    return cast(Any, value)
+
+
+def deserialize(value: Any) -> Any:
+    """Recursively deserialize OCaml yojson to Python AST objects."""
+    if value is None:
+        return None
+
+    if isinstance(value, (str, int, float, bool, bytes)):
+        return value
+
+    if isinstance(value, dict):
+        # Recursively deserialize dict values
+        value_dict = cast(dict[str, Any], value)
+        result: dict[str, Any] = {}
+        for k, v in value_dict.items():
+            result[k] = deserialize(v)
+        return result
+
+    if isinstance(value, list):
+        value_list = cast(list[Any], value)
+        # Check if it's a tagged tuple ["Tag", ...] or just a list
+        if len(value_list) >= 1 and isinstance(value_list[0], str):
+            tag: str = value_list[0]
+
+            # Empty variant: ["Tag"]
+            if len(value_list) == 1:
+                return getattr(ast, tag)()
+
+            # Variant with data: ["Tag", {...}]
+            if len(value_list) == 2 and isinstance(value_list[1], dict):
+                data: dict[str, Any] = cast(dict[str, Any], value_list[1])
+
+                # Special handling: OCaml's ExprStmt maps to Python's Expr
+                if tag == 'ExprStmt':
+                    tag = 'Expr'
+
+                cls = getattr(ast, tag)
+
+                # Special handling for Constant.value field
+                if tag == 'Constant' and 'value' in data:
+                    kwargs: dict[str, Any] = {}
+                    for k, v in data.items():
+                        if k != 'value':  # Skip 'value' - handle it specially below
+                            kwargs[k] = deserialize(v)
+                    kwargs['value'] = deserialize_constant_value(data['value'])
+                    return cls(**kwargs)
+
+                # Recursively deserialize all fields
+                kwargs2: dict[str, Any] = {}
+                for k, v in data.items():
+                    kwargs2[k] = deserialize(v)
+                return cls(**kwargs2)
+
+        # Plain list - recursively deserialize elements
+        result_list: list[Any] = []
+        for item in value_list:
+            result_list.append(deserialize(item))
+        return result_list
+
+    return value
+
+
+def _stmts_of_json_data(json_data: list[Any]) -> list[ast.stmt]:
+    """Load a list of statements from OCaml JSON."""
+    return deserialize(json_data)
+
+
+def stmts_of_json(json_string: str) -> list[ast.stmt]:
+    """Load statements from a JSON string."""
+    import json
+
+    data = json.loads(json_string)
+    return _stmts_of_json_data(data)

imandrax_codegen/ast_types.py

@@ -0,0 +1,472 @@
+"""This module closely follows the structure from lib/ast.ml with
+dataclass decorators added.
+"""
+
+from __future__ import annotations
+
+from pydantic import ConfigDict
+from pydantic.dataclasses import dataclass
+
+dc = dataclass(config=ConfigDict(arbitrary_types_allowed=True))
+
+
+@dc
+class AST:
+    pass
+
+
+@dc
+class mod(AST):
+    pass
+
+
+@dc
+class Module(mod):
+    body: list[stmt]
+
+
+@dc
+class stmt:
+    # lineno: int
+    # col_offset: int
+    # end_lineno: int | None
+    # end_col_offset: int | None
+    pass
+
+
+@dc
+class ClassDef(stmt):
+    name: str
+    bases: list[expr]
+    keywords: list[keyword]
+    body: list[stmt]
+    decorator_list: list[expr]
+
+
+@dc
+class Assign(stmt):
+    targets: list[expr]
+    value: expr
+    type_comment: str | None
+
+
+@dc
+class AugAssign(stmt):
+    target: Name | Attribute | Subscript
+    op: operator
+    value: expr
+
+
+@dc
+class AnnAssign(stmt):
+    target: Name | Attribute | Subscript
+    annotation: expr
+    value: expr | None
+    simple: int
+
+
+@dc
+class Expr(stmt):
+    # L792
+    value: expr
+
+
+@dc
+class Pass(stmt):
+    pass
+
+
+@dc
+class expr(AST):
+    pass
+    # lineno: int
+    # col_offset: int
+    # end_lineno: int | None
+    # end_col_offset: int | None
+
+
+@dc
+class BoolOp(expr):
+    op: boolop
+    values: list[expr]
+
+
+@dc
+class BinOp(expr):
+    left: expr
+    op: operator
+    right: expr
+
+
+@dc
+class UnaryOp(expr):
+    op: unaryop
+    operand: expr
+
+
+@dc
+class Dict(expr):
+    keys: list[expr | None]
+    values: list[expr]
+
+
+@dc
+class Set(expr):
+    elts: list[expr]
+
+
+@dc
+class Call(expr):
+    # L1024
+    func: expr
+    args: list[expr]
+    keywords: list[keyword]
+
+
+# original: `_ConstantValue: typing_extensions.TypeAlias = ...`
+type _ConstantValue = (
+    str | bytes | bool | int | float | complex | None
+    # | EllipsisType
+)
+
+
+@dc
+class Constant(expr):
+    # L1037
+    value: _ConstantValue
+    kind: str | None
+
+
+@dc
+class Attribute(expr):
+    value: expr
+    attr: str
+    ctx: expr_context
+
+
+@dc
+class Subscript(expr):
+    # L1139
+    value: expr
+    slice: expr
+    ctx: expr_context
+
+
+@dc
+class Name(expr):
+    # L1162
+    id: str
+    ctx: expr_context
+
+
+@dc
+class List(expr):
+    # L1175
+    elts: list[expr]
+    ctx: expr_context
+
+
+@dc
+class Tuple(expr):
+    # L1185
+    elts: list[expr]
+    ctx: expr_context
+    # dims: list[expr]
+
+
+@dc
+class expr_context(AST):
+    pass
+
+
+@dc
+class Load(expr_context):
+    # L1239
+    pass
+
+
+@dc
+class Store(expr_context):
+    pass
+
+
+@dc
+class Del(expr_context):
+    pass
+
+
+@dc
+class boolop(AST):
+    pass
+
+
+@dc
+class And(boolop):
+    pass
+
+
+@dc
+class Or(boolop):
+    pass
+
+
+@dc
+class operator(AST):
+    pass
+
+
+@dc
+class Add(operator):
+    pass
+
+
+@dc
+class Sub(operator):
+    pass
+
+
+@dc
+class Mult(operator):
+    pass
+
+
+@dc
+class MatMult(operator):
+    pass
+
+
+@dc
+class Div(operator):
+    pass
+
+
+@dc
+class Mod(operator):
+    pass
+
+
+@dc
+class Pow(operator):
+    pass
+
+
+@dc
+class LShift(operator):
+    pass
+
+
+@dc
+class RShift(operator):
+    pass
+
+
+@dc
+class BitOr(operator):
+    pass
+
+
+@dc
+class BitXor(operator):
+    pass
+
+
+@dc
+class BitAnd(operator):
+    pass
+
+
+@dc
+class FloorDiv(operator):
+    pass
+
+
+@dc
+class unaryop(AST):
+    pass
+
+
+@dc
+class Invert(unaryop):
+    pass
+
+
+@dc
+class Not(unaryop):
+    pass
+
+
+@dc
+class UAdd(unaryop):
+    pass
+
+
+@dc
+class USub(unaryop):
+    pass
+
+
+@dc
+class cmpop(AST):
+    pass
+
+
+@dc
+class Eq(cmpop):
+    pass
+
+
+@dc
+class NotEq(cmpop):
+    pass
+
+
+@dc
+class Lt(cmpop):
+    pass
+
+
+@dc
+class LtE(cmpop):
+    pass
+
+
+@dc
+class Gt(cmpop):
+    pass
+
+
+@dc
+class GtE(cmpop):
+    pass
+
+
+@dc
+class Is(cmpop):
+    pass
+
+
+@dc
+class IsNot(cmpop):
+    pass
+
+
+@dc
+class In(cmpop):
+    pass
+
+
+@dc
+class NotIn(cmpop):
+    pass
+
+
+@dc
+class arg(AST):
+    # lineno: int
+    # col_offset: int
+    # end_lineno: int | None
+    # end_col_offset: int | None
+    arg: str
+    annotation: expr | None
+    type_comment: str | None
+
+
+@dc
+class keyword(AST):
+    # lineno: int
+    # col_offset: int
+    # end_lineno: int | None
+    # end_col_offset: int | None
+    arg: str | None
+    value: expr
+
+
+@dc
+class arguments(AST):
+    posonlyargs: list[arg]
+    args: list[arg]
+    vararg: arg | None
+    kwonlyargs: list[arg]
+    kw_defaults: list[expr | None]
+    kwarg: arg | None
+    defaults: list[expr]
+
+
+@dc
+class Lambda(expr):
+    args: arguments
+    body: expr
+
+
+@dc
+class type_param(AST):
+    # lineno: int
+    # col_offset: int
+    # end_lineno: int
+    # end_col_offset: int
+    pass
+
+
+@dc
+class TypeVar(type_param):
+    name: str
+    bound: expr | None
+    default_value: expr | None
+
+
+@dc
+class ParamSpec(type_param):
+    name: str
+    default_value: expr | None
+
+
+@dc
+class TypeVarTuple(type_param):
+    name: str
+    default_value: expr | None
+
+
+@dc
+class FunctionDef(stmt):
+    name: str
+    args: arguments
+    body: list[stmt]
+    decorator_list: list[expr]
+    returns: expr | None
+    type_comment: str | None
+    type_params: list[type_param]
+
+
+@dc
+class alias(AST):
+    name: str
+    asname: str | None
+    # lineno: int
+    # col_offset: int
+    # end_lineno: int | None
+    # end_col_offset: int | None
+
+
+@dc
+class Assert(stmt):
+    test: expr
+    msg: expr | None
+
+
+@dc
+class Import(stmt):
+    names: list[alias]
+
+
+@dc
+class ImportFrom(stmt):
+    module: str | None
+    names: list[alias]
+    level: int
+
+
+@dc
+class Compare(expr):
+    left: expr
+    ops: list[cmpop]
+    comparators: list[expr]

imandrax_codegen/code_of_ast/__main__.py

@@ -0,0 +1,66 @@
+#!/usr/bin/env python
+"""CLI tool to convert OCaml AST JSON to Python source code."""
+
+import sys
+from pathlib import Path
+from typing import Annotated
+
+import typer
+from imandrax_codegen.ast_deserialize import stmts_of_json
+from imandrax_codegen.unparse import unparse
+
+app = typer.Typer()
+
+
+@app.command(name='code-of-ocaml-ast')
+def code_of_ocaml_ast(
+    input_file: Annotated[
+        str,
+        typer.Argument(help="Input JSON file (from OCaml yojson), or '-' for stdin"),
+    ],
+    output: Annotated[
+        str | None,
+        typer.Option(
+            '-o',
+            '--output',
+            help='Output Python file (writes to stdout if not provided)',
+        ),
+    ] = None,
+    include_real_to_float_alias: Annotated[
+        bool,
+        typer.Option(
+            '--include-real-to-float-alias', help='Include real to float alias'
+        ),
+    ] = False,
+) -> None:
+    """Convert OCaml AST JSON to Python source code."""
+    # Read and deserialize
+    if input_file == '-':
+        json_str = sys.stdin.read()
+    else:
+        with Path(input_file).open() as f:
+            json_str = f.read()
+
+    if not json_str:
+        typer.echo('imandrax_codegen error: Input is empty', err=True)
+        raise typer.Exit(code=1)
+
+    stmts = stmts_of_json(json_str)
+
+    # Generate Python code
+    python_code = unparse(
+        stmts,
+        alias_real_to_float=include_real_to_float_alias,
+    )
+
+    # Write output
+    if output:
+        with Path(output).open('w') as f:
+            f.write(python_code)
+            f.write('\n')
+    else:
+        typer.echo(python_code)
+
+
+if __name__ == '__main__':
+    app()

imandrax_codegen/output.py

@@ -0,0 +1,11 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class Waitlist:
+    arg0: int
+    arg1: bool
+
+
+Status = Waitlist
+w = Status(2, True)

imandrax_codegen/test_gen.py

@@ -0,0 +1,112 @@
+__test__ = False  # this is not a test
+import os
+import re
+from pathlib import Path
+from typing import Any, cast
+
+import imandrax_codegen.ast_types as ast_types
+from imandrax_api import Client, url_dev, url_prod  # noqa: F401
+from imandrax_api.bindings.artmsg_pb2 import Art as PbArt
+from imandrax_api_models import Art, DecomposeRes, EvalRes  # noqa: F401, RUF100
+from imandrax_api_models.client import ImandraXClient
+
+from .art_parse import ast_of_art
+
+curr_dir = Path(__file__).parent
+
+
+def get_fun_arg_types(fun_name: str, iml: str, c: ImandraXClient) -> list[str] | None:
+    """Get the argument types of a function."""
+    tc_res = c.typecheck(iml)
+    name_ty_map = {ty.name: ty.ty for ty in tc_res.types}
+    if fun_name not in name_ty_map:
+        return None
+
+    return list(map(lambda s: s.strip(), name_ty_map[fun_name].split('->')))
+
+
+def extract_type_decl_names(iml_code: str) -> list[str]:
+    """
+    Extract all type definition names from OCaml code using regex.
+
+    Args:
+        ocaml_code: String containing OCaml code
+
+    Returns:
+        List of type names defined in the code
+
+    Examples:
+        >>> code = 'type direction = North | South'
+        >>> extract_ocaml_type_names(code)
+        ['direction']
+    """
+    # Pattern matches: "type" or "and" keyword followed by optional type parameters, then type name
+    # Handles both regular types and recursive types (type ... and ...)
+    # Also handles parameterized types:
+    #   - Single param without parens: type 'a option
+    #   - Multi param with parens: type ('a, 'b) container
+    #   - Wildcard param: type _ expr (GADTs)
+    pattern = r'\b(?:type|and)\s+(?:(?:\([^)]+\)|\'[a-z_][a-zA-Z0-9_]*|_)\s+)?([a-z_][a-zA-Z0-9_]*(?:\s*,\s*[a-z_][a-zA-Z0-9_]*)*)'
+
+    matches = re.finditer(pattern, iml_code)
+    type_names: list[str] = []
+
+    for match in matches:
+        # Extract the captured group (type name(s))
+        names = match.group(1)
+        # Split by comma in case of mutually recursive types: type t1, t2 = ...
+        for name in names.split(','):
+            type_names.append(name.strip())
+
+    return type_names
+
+
+# Main
+# ====================
+
+
+def gen_test_cases(
+    iml: str,
+    decomp_name: str,
+    other_decomp_kwargs: dict[str, Any] | None = None,
+) -> list[ast_types.stmt]:
+    other_decomp_kwargs = other_decomp_kwargs or {}
+
+    c = ImandraXClient(
+        auth_token=os.environ['IMANDRAX_API_KEY'],
+        # url=url_dev,
+        url=url_prod,
+    )
+
+    # Eval IML
+    eval_res: EvalRes = c.eval_src(iml)
+    if eval_res.success is not True:
+        error_msgs = [repr(err.msg) for err in eval_res.errors]
+        raise ValueError(f'Failed to evaluate source code: {error_msgs}')
+
+    # TODO: it's fixed. We should revert this change
+    # decomp_res: DecomposeRes = c.decompose(decomp_name, **other_decomp_kwargs)
+    # decomp_art = decomp_res.artifact
+    # assert decomp_art, 'No artifact returned from decompose'
+    # The decoding of fun-decomp artifact is broken, we fallback to the naive
+    # API client which does not have region extraction
+    decomp_res_proto = Client.decompose(c, decomp_name, **other_decomp_kwargs)
+    decomp_art = Art.model_validate(cast(PbArt, decomp_res_proto.artifact))  # type: ignore[reportUnknownMemberType]
+    assert decomp_art, 'No artifact returned from decompose'
+
+    arg_types: list[str] = extract_type_decl_names(iml)
+
+    # Type declarations
+    decls = c.get_decls(arg_types)
+    type_def_stmts_by_decl = [
+        ast_of_art(decl.artifact, mode='decl') for decl in decls.decls
+    ]
+    type_def_stmts = [stmt for stmts in type_def_stmts_by_decl for stmt in stmts]
+
+    # Test function definitions
+    test_def_stmts = ast_of_art(decomp_art, mode='fun-decomp')
+
+    return [
+        *type_def_stmts,
+        *test_def_stmts,
+    ]

imandrax_codegen/unparse.py

@@ -0,0 +1,188 @@
+"""Convert custom AST to Python stdlib AST and unparse to source code."""
+
+import ast as stdlib_ast
+import subprocess
+from typing import Any, Final, cast
+
+from ruff.__main__ import find_ruff_bin
+
+from . import ast_types as custom_ast
+
+ruff_bin = find_ruff_bin()
+
+
+OPTION_LIB_SRC: Final[str] = """\
+T = TypeVar('T')
+
+
+@dataclass
+class Some(Generic[T]):
+    value: T
+
+option: TypeAlias = Some[T] | None
+"""
+
+
+def format_code(code: str) -> str:
+    """Format Python code using ruff."""
+
+    # Sort imports
+    code = fix_ruff_check(code, ['I001'])
+
+    try:
+        result = subprocess.run(
+            [ruff_bin, 'format', '-'],
+            input=code,
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        return result.stdout
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        # If ruff fails or is not found, return original code
+        return code
+
+
+def fix_ruff_check(code: str, rules: list[str]) -> str:
+    """Lint and fix code with ruff for the given rules."""
+
+    if not rules:
+        return code
+
+    ruff_bin = find_ruff_bin()
+
+    try:
+        result = subprocess.run(
+            [ruff_bin, 'check', '--select', ','.join(rules), '--fix', '-'],
+            check=False,
+            input=code,
+            capture_output=True,
+            text=True,
+        )
+        # ruff check outputs fixed code to stdout
+        return result.stdout if result.stdout else code
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        # If ruff fails or is not found, return original code
+        return code
+
+
+def remove_unused_import(code: str) -> str:
+    """Remove unused imports from code."""
+    return fix_ruff_check(code, ['F401'])
+
+
+def to_stdlib(node: Any) -> Any:
+    """Recursively convert custom AST node to stdlib AST node."""
+    if node is None:
+        return None
+
+    # Handle primitive types
+    if isinstance(node, (str, int, float, bool, bytes)):
+        return node
+
+    # Handle lists
+    if isinstance(node, list):
+        node_list = cast(list[Any], node)
+        result: list[Any] = []
+        for item in node_list:
+            result.append(to_stdlib(item))
+        return result
+
+    # Handle custom AST nodes - get the corresponding stdlib class by name
+    class_name = node.__class__.__name__
+    stdlib_class = getattr(stdlib_ast, class_name, None)
+
+    if stdlib_class is None:
+        raise ValueError(f'No stdlib AST class found for: {class_name}')
+
+    # Get all fields from the custom node and recursively convert them
+    kwargs: dict[str, Any] = {}
+    for field_name, field_value in node.__dict__.items():
+        kwargs[field_name] = to_stdlib(field_value)
+
+    return stdlib_class(**kwargs)
+
+
+def unparse(
+    nodes: list[custom_ast.stmt],
+    alias_real_to_float: bool = False,
+    # TODO: add a config field?
+    # - [x] whether to alias `real` to `float` or not
+    #   - [ ] alternatively: use Decimal instead of float
+    # - the python version to use: 3.12+ or not
+    #   - this determines the type definition syntax
+    # # 3.12+
+    # class Pair[A, B]:
+    #     first: A
+    #     second: B
+    # # ----
+    # # 3.11-
+    # A = TypeVar('A')
+    # B = TypeVar('B')
+    # class Pair(Generic[A, B]):
+    #     first: A
+    #     second: B
+    # TODO: use ruff upgrade and --target-version parameter
+) -> str:
+    """Convert custom AST to Python source code using stdlib ast.unparse."""
+    stdlib_stmts: list[stdlib_ast.stmt] = to_stdlib(nodes)
+
+    def mk_ast(src: str) -> list[stdlib_ast.stmt]:
+        return stdlib_ast.parse(src).body
+
+    def gen_code(stmts: list[stdlib_ast.stmt]) -> str:
+        """Generate Python source code from a list of AST statements."""
+        module = stdlib_ast.Module(body=stmts, type_ignores=[])
+        stdlib_ast.fix_missing_locations(module)
+        return stdlib_ast.unparse(module)
+
+    future_annotations_import = stdlib_ast.ImportFrom(
+        module='__future__',
+        names=[stdlib_ast.alias(name='annotations', asname=None)],
+        level=0,
+    )
+    dataclass_import = stdlib_ast.ImportFrom(
+        module='dataclasses',
+        names=[stdlib_ast.alias(name='dataclass', asname=None)],
+        level=0,
+    )
+    typing_import = stdlib_ast.ImportFrom(
+        module='typing',
+        names=[
+            stdlib_ast.alias(name='TypeVar', asname=None),
+            stdlib_ast.alias(name='Generic', asname=None),
+            stdlib_ast.alias(name='TypeAlias', asname=None),
+        ],
+        level=0,
+    )
+    option_lib_import = mk_ast('from imandrax_option_lib import option, Some')
+    option_lib_definition: list[stdlib_ast.stmt] = mk_ast(OPTION_LIB_SRC)
+    alias_real: list[stdlib_ast.stmt] = mk_ast('real = float')
+
+    body = [
+        future_annotations_import,
+        dataclass_import,
+        typing_import,
+        *option_lib_import,
+        *(alias_real if alias_real_to_float else []),
+        *stdlib_stmts,
+    ]
+
+    code = gen_code(body)
+
+    code = remove_unused_import(code)
+
+    # After removing unused imports, if "from imandrax_option_lib" is still present,
+    # it means that the option_lib definition is needed
+    if 'from imandrax_option_lib' in code:
+        body = [
+            future_annotations_import,
+            dataclass_import,
+            typing_import,
+            *option_lib_definition,
+            *(alias_real if alias_real_to_float else []),
+            *stdlib_stmts,
+        ]
+        code = gen_code(body)
+
+    return format_code(code)

imandrax_codegen-18.1.1.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.4
+Name: imandrax-codegen
+Version: 18.1.1
+Summary: Code generator for ImandraX artifact
+Author-email: hongyu <hongyu@imandra.ai>
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: devtools>=0.12.2
+Requires-Dist: dotenv>=0.9.9
+Requires-Dist: imandrax-api-models>=18.0.0
+Requires-Dist: imandrax-api[async]>=0.18.0.1
+Requires-Dist: iml-query>=0.3.4
+Requires-Dist: pydantic>=2.12.3
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: rich>=14.2.0
+Requires-Dist: ruff>=0.14.3
+Requires-Dist: typer>=0.21.0
+
+# ImandraX Code Generator
+
+Code generator for ImandraX artifact

imandrax_codegen-18.1.1.dist-info/RECORD

@@ -0,0 +1,15 @@
+imandrax_codegen/__main__.py,sha256=8MRtWTKcBa6ip1mCm0suZSrawTHcGgXj5M7WrZ6gTOo,1096
+imandrax_codegen/art_parse.exe,sha256=C-KBJWPejMYFseJel-h6LQoSjhZlMkL-k9Us6BMJk-Q,11236424
+imandrax_codegen/art_parse.py,sha256=tDj7_FJjpl1uUMx056Y5WAUVHM3hoBD-0uW60GPD5PY,3244
+imandrax_codegen/ast_deserialize.py,sha256=n_Mjpb3qMzXKFjHt4s4HvTOmfDt9trcuWFkvN8iak6c,3329
+imandrax_codegen/ast_types.py,sha256=xMg6qKQtLO7-iOEP5sDlUFWQrw0xre8y6QWpSZEynxE,5320
+imandrax_codegen/output.py,sha256=BSr9xxYau9acHLDYaIt2eJcoQ5sGbzmtcs1859srvpA,132
+imandrax_codegen/test_gen.py,sha256=pyx6Qk0zFjzJuYipyk9gdnNcbWz00N8vZ7Qdoy6FkNM,3799
+imandrax_codegen/unparse.py,sha256=ejfYx-ttVIhN3aG9vHlzRDy8q3jHmCsjDWNYq6xxdPI,5469
+imandrax_codegen/code_of_ast/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+imandrax_codegen/code_of_ast/__main__.py,sha256=fAsdippqbtGvMUqOChRc--EZbfFkKSgdNjdbWdOXzTo,1634
+imandrax_codegen-18.1.1.dist-info/METADATA,sha256=7L1duYkrRYkY2jZ0Nu0dowWuXvrhYtsz9SDKNqH62aM,604
+imandrax_codegen-18.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+imandrax_codegen-18.1.1.dist-info/entry_points.txt,sha256=4dag2GtGgO2COW5g6OvQhzDQaWe79ysyQgcJLNOBwOw,67
+imandrax_codegen-18.1.1.dist-info/top_level.txt,sha256=DSAK5XzSRhi4WC4SloQIsDPNK9_B6bKVmnxukfyCozc,17
+imandrax_codegen-18.1.1.dist-info/RECORD,,

imandrax_codegen-18.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

imandrax_codegen-18.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+imandrax-codegen = imandrax_codegen.__main__:app

imandrax_codegen-18.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+imandrax_codegen