imandrax-api-models 1.0.0__tar.gz

imandrax_api_models-1.0.0/PKG-INFO

@@ -0,0 +1,15 @@
+Metadata-Version: 2.3
+Name: imandrax-api-models
+Version: 1.0.0
+Summary: Add your description here
+Author: hongyu
+Author-email: hongyu <hongyu@imandra.ai>
+Requires-Dist: devtools>=0.12.2
+Requires-Dist: imandrax-api[async]>=0.17.3.1
+Requires-Dist: pydantic>=2.12.4
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# ImandraX API Models
+
+Pydantic models for the ImandraX API.

imandrax_api_models-1.0.0/README.md

@@ -0,0 +1,3 @@
+# ImandraX API Models
+
+Pydantic models for the ImandraX API.

imandrax_api_models-1.0.0/pyproject.toml

@@ -0,0 +1,93 @@
+[project]
+name = "imandrax-api-models"
+version = "1.0.0"
+description = "Add your description here"
+readme = "README.md"
+authors = [
+    { name = "hongyu", email = "hongyu@imandra.ai" }
+]
+requires-python = ">=3.12"
+dependencies = [
+    "devtools>=0.12.2",
+    "imandrax-api[async]>=0.17.3.1",
+    "pydantic>=2.12.4",
+]
+
+[build-system]
+requires = ["uv_build>=0.8.22,<0.9.0"]
+build-backend = "uv_build"
+
+
+[tool.uv.sources]
+
+
+[[tool.uv.index]]
+name = "testpypi"
+url = "https://test.pypi.org/simple/"
+publish-url = "https://test.pypi.org/legacy/"
+explicit = true
+
+[dependency-groups]
+dev = [
+    "inline-snapshot[dirty-equals]>=0.31.1",
+    "ipykernel>=7.1.0",
+    "pytest>=9.0.1",
+    "pyyaml>=6.0.3",
+]
+
+[tool.ruff.lint]
+extend-select = [
+    "Q",
+    "RUF100",
+    "RUF018", # https://docs.astral.sh/ruff/rules/assignment-in-assert/
+    "C90",
+    "UP",
+    "I",
+    "D",
+    "TID251",
+]
+flake8-quotes = { inline-quotes = "single", multiline-quotes = "double" }
+mccabe = { max-complexity = 15 }
+ignore = [
+    "D100", # ignore missing docstring in module
+    "D101", # ignore missing docstring in public class
+    "D102", # ignore missing docstring in public method
+    "D103", # ignore missing docstring in public function
+    "D104", # ignore missing docstring in public package
+    "D105", # ignore missing docstring in magic methods
+    "D106", # ignore missing docstring in public nested class
+    "D107", # ignore missing docstring in __init__ methods
+    "D203",
+    "D212",
+]
+pycodestyle.ignore-overlong-task-comments = true
+isort.combine-as-imports = true
+
+[tool.ruff.lint.per-file-ignores]
+"scripts/**/*.py" = ["F401", "RUF100", "D", "E402", "B018"]
+"data/**/*.py" = ["F401", "RUF100", "D", "E402", "B018"]
+
+[tool.ruff.format]
+quote-style = "single"
+
+[tool.ty]
+environment.python = "./.venv"
+
+[tool.ty.rules]
+# Handled by pyright
+unsupported-operator = "ignore"
+invalid-argument-type = "ignore"
+invalid-return-type = "ignore"
+possibly-missing-attribute = "ignore"
+unresolved-import = "ignore"
+
+[tool.pyright]
+venvPath = "."
+venv = ".venv"
+pythonVersion = "3.12"
+typeCheckingMode = "strict"
+reportMissingTypeStubs = false
+reportUnnecessaryIsInstance = false
+reportUnnecessaryTypeIgnoreComment = true
+reportUnusedImport = "none"
+reportUnusedExpression = false

imandrax_api_models-1.0.0/src/imandrax_api_models/__init__.py

@@ -0,0 +1,93 @@
+from .proto_models import (
+    Art,
+    CounterSat,
+    DecomposeReq,
+    DecomposeRes,
+    Empty,
+    Error,
+    ErrorKind,
+    ErrorMessage,
+    EvalOutput,
+    EvalRes,
+    EvalSrcReq,
+    InferredType,
+    InstanceNameReq,
+    InstanceRes,
+    InstanceSrcReq,
+    LiftBool,
+    Location,
+    Model,
+    ModelType,
+    OneshotReq,
+    OneshotRes,
+    Origin,
+    PO_Res,
+    Position,
+    Proved,
+    Refuted,
+    RegionStr,
+    Sat,
+    Session,
+    SessionCreate,
+    SessionCreateReq,
+    SessionOpen,
+    StorageEntry,
+    StringMsg,
+    Task,
+    TaskID,
+    TaskKind,
+    TypecheckReq,
+    TypecheckRes,
+    Unsat,
+    Verified_upto,
+    VerifyNameReq,
+    VerifyRes,
+    VerifySrcReq,
+)
+
+__all__ = [
+    'Art',
+    'CounterSat',
+    'DecomposeReq',
+    'DecomposeRes',
+    'Empty',
+    'Error',
+    'ErrorKind',
+    'ErrorMessage',
+    'EvalOutput',
+    'EvalRes',
+    'EvalSrcReq',
+    'InferredType',
+    'InstanceNameReq',
+    'InstanceRes',
+    'InstanceSrcReq',
+    'LiftBool',
+    'Location',
+    'Model',
+    'ModelType',
+    'OneshotReq',
+    'OneshotRes',
+    'Origin',
+    'PO_Res',
+    'Position',
+    'Proved',
+    'Refuted',
+    'RegionStr',
+    'Sat',
+    'Session',
+    'SessionCreate',
+    'SessionCreateReq',
+    'SessionOpen',
+    'StorageEntry',
+    'StringMsg',
+    'Task',
+    'TaskID',
+    'TaskKind',
+    'TypecheckReq',
+    'TypecheckRes',
+    'Unsat',
+    'Verified_upto',
+    'VerifyNameReq',
+    'VerifyRes',
+    'VerifySrcReq',
+]

imandrax_api_models-1.0.0/src/imandrax_api_models/decode_artifact_local.py

@@ -0,0 +1,207 @@
+from __future__ import annotations
+
+import base64
+from dataclasses import dataclass
+from typing import Any, assert_never
+
+from imandrax_api.lib import (
+    Artifact,
+    Common_Applied_symbol_t_poly,
+    Common_Fun_decomp_t_poly,
+    Common_Model_t_poly,
+    Common_Region_meta_Assoc,
+    Common_Region_meta_String,
+    Common_Region_meta_Term,
+    Common_Region_t_poly,
+    Common_Var_t_poly,
+    Mir_Fun_decomp,
+    Mir_Term,
+    Mir_Term_view_Const,
+    Mir_Term_view_Construct,
+    Mir_Type,
+    Uid,
+    read_artifact_data,
+)
+
+
+@dataclass
+class RegionStr:
+    constraints_str: list[str] | None
+    invariant_str: str
+    model_str: dict[str, str]
+    model_eval_str: str | None
+
+
+class ArtifactDecodeError(Exception):
+    pass
+
+
+def decode_artifact(
+    data: bytes | str,
+    kind: str,
+) -> list[RegionStr] | dict[str, str] | None:
+    data_b: bytes = base64.b64decode(data) if isinstance(data, str) else data
+    art: Artifact = read_artifact_data(data=data_b, kind=kind)
+    match (art, kind):
+        case (
+            Common_Fun_decomp_t_poly(
+                f_id=_f_id,
+                f_args=_f_args,
+                regions=regions,
+            ) as _fun_decomp,
+            'mir.fun_decomp',
+        ):
+            _fun_decomp: Mir_Fun_decomp
+            _f_id: Uid
+            _f_args: list[Common_Var_t_poly[Mir_Type]]
+            regions: list[Common_Region_t_poly[Mir_Term, Mir_Type]]
+
+            return unwrap_region_str(regions)
+        case (
+            Common_Model_t_poly(
+                # list[tuple[Mir_Type, Common_Model_ty_def[Mir_Term, Mir_Type]]]
+                tys=_,
+                consts=consts,
+                # list[
+                #     tuple[
+                #         Common_Applied_symbol_t_poly[Mir_Type],
+                #         Common_Model_fi[Mir_Term, Mir_Type],
+                #     ]
+                # ]
+                funs=_,
+                # bool
+                representable=_,
+                # bool
+                completed=_,
+                # list[tuple[Uid, Mir_Type]]
+                ty_subst=_,
+            ) as _mir_model,
+            'mir.model',
+        ):
+            consts: list[tuple[Common_Applied_symbol_t_poly[Mir_Type], Mir_Term]]
+            consts_d: dict[str, Any] = unwrap_model_constants(consts)
+            return consts_d
+        case _:
+            raise ArtifactDecodeError(
+                f'Unknown artifact type: {type(art)}, with {kind = }'
+            )
+
+
+def unwrap_model_constants(
+    consts: list[tuple[Common_Applied_symbol_t_poly[Mir_Type], Mir_Term]],
+) -> dict[str, Any]:
+    constants: dict[str, Any] = {}
+
+    for applied_symbol, term in consts:
+        match applied_symbol, term:
+            case (
+                Common_Applied_symbol_t_poly(
+                    sym=applied_symbol_sym,
+                    args=_,
+                    ty=_,
+                ),
+                Mir_Term(view=term_view, ty=_, sub_anchor=_),
+            ):
+                var_name = applied_symbol_sym.id.name
+
+                # Extract the value from the term
+                match term_view:
+                    case Mir_Term_view_Const(arg=term_view_const):
+                        constants[var_name] = term_view_const.arg
+                    case Mir_Term_view_Construct():
+                        raise NotImplementedError(
+                            'Term view type of Mir_Term_view_Construct is not supported'
+                        )
+                    case _:
+                        raise NotImplementedError(
+                            f'Unexpected term view type: {type(term_view)}'
+                        )
+
+    return constants
+
+
+type region_meta_value = (
+    Common_Region_meta_Assoc[Mir_Term]
+    | Common_Region_meta_Term[Mir_Term]
+    | Common_Region_meta_String[Mir_Term]
+)
+
+
+def unwrap_region_str(
+    regions: list[Common_Region_t_poly[Mir_Term, Mir_Type]],
+) -> list[RegionStr]:
+    """
+    Get `RegionStr`s from a list of `Region.t`.
+
+    A region object looks like:
+    {
+        "constraints": [...],
+        "invariant": ...,
+        "meta": [
+            ("str", ...)  # What we want
+            ("model", ...)
+            ("model_eval", ...)
+            ("id", "...")
+        ]
+        "status": ...
+    }.
+    """
+    regions_str: list[RegionStr] = []
+    for region in regions:
+        match region:
+            case Common_Region_t_poly(
+                constraints=_constraints,
+                invariant=_invariant,
+                meta=meta,
+                status=_status,
+            ):
+                # Convert meta list to dict
+                meta_d: dict[Any, Any] = dict(meta)
+
+                # get `str` dict
+                meta_str_raw = meta_d.get('str')
+                assert meta_str_raw is not None, "Never: no 'str' in meta"
+
+                # meta_str should be Common_Region_meta_Assoc[Mir_Term]
+                if not isinstance(meta_str_raw, Common_Region_meta_Assoc):
+                    raise ValueError(
+                        f'Expected Common_Region_meta_Assoc, got {type(meta_str_raw)}'
+                    )
+
+                meta_str_d: dict[Any, Any] = dict(meta_str_raw.arg)  # type: ignore[arg-type]
+
+                # Extract constraints
+                constraints_raw = meta_str_d.get('constraints')
+                constraints: list[str] | None
+                if constraints_raw is not None:
+                    constraints = [c.arg for c in constraints_raw.arg]
+                else:
+                    constraints = None
+
+                # Extract invariant
+                invariant_raw = meta_str_d.get('invariant')
+                invariant: str = invariant_raw.arg if invariant_raw is not None else ''
+
+                # Extract model
+                model_raw = meta_str_d.get('model')
+                model: dict[str, str] = {}
+                if model_raw is not None:
+                    model = {k: v.arg for (k, v) in model_raw.arg}
+
+                # Extract model_eval (optional)
+                model_eval: str | None = None
+                if 'model_eval' in meta_str_d:
+                    model_eval_raw = meta_str_d['model_eval']
+                    if model_eval_raw is not None:
+                        model_eval = model_eval_raw.arg
+
+                region_str = RegionStr(
+                    invariant_str=invariant,
+                    constraints_str=constraints,
+                    model_str=model,
+                    model_eval_str=model_eval,
+                )
+                regions_str.append(region_str)
+            case _:
+                assert_never(region)
+    return regions_str

imandrax_api_models-1.0.0/src/imandrax_api_models/proto_models/__init__.py

@@ -0,0 +1,83 @@
+from .artmsg import Art, StorageEntry
+from .error import Error, ErrorKind, ErrorMessage
+from .locs import Location, Position
+from .session import Session, SessionCreate, SessionOpen
+from .simple_api import (
+    CounterSat,
+    DecomposeReq,
+    DecomposeRes,
+    EvalOutput,
+    EvalRes,
+    EvalSrcReq,
+    InferredType,
+    InstanceNameReq,
+    InstanceRes,
+    InstanceSrcReq,
+    LiftBool,
+    Model,
+    ModelType,
+    OneshotReq,
+    OneshotRes,
+    PO_Res,
+    Proved,
+    Refuted,
+    RegionStr,
+    Sat,
+    SessionCreateReq,
+    TypecheckReq,
+    TypecheckRes,
+    Unsat,
+    Verified_upto,
+    VerifyNameReq,
+    VerifyRes,
+    VerifySrcReq,
+)
+from .task import Origin, Task, TaskID, TaskKind
+from .utils import Empty, StringMsg
+
+__all__ = [
+    'Art',
+    'CounterSat',
+    'DecomposeReq',
+    'DecomposeRes',
+    'Empty',
+    'Error',
+    'ErrorKind',
+    'ErrorMessage',
+    'EvalOutput',
+    'EvalRes',
+    'EvalSrcReq',
+    'InferredType',
+    'InstanceNameReq',
+    'InstanceRes',
+    'InstanceSrcReq',
+    'LiftBool',
+    'Location',
+    'Model',
+    'ModelType',
+    'OneshotReq',
+    'OneshotRes',
+    'Origin',
+    'PO_Res',
+    'Position',
+    'Proved',
+    'Refuted',
+    'RegionStr',
+    'Sat',
+    'Session',
+    'SessionCreate',
+    'SessionCreateReq',
+    'SessionOpen',
+    'StorageEntry',
+    'StringMsg',
+    'Task',
+    'TaskID',
+    'TaskKind',
+    'TypecheckReq',
+    'TypecheckRes',
+    'Unsat',
+    'Verified_upto',
+    'VerifyNameReq',
+    'VerifyRes',
+    'VerifySrcReq',
+]

imandrax_api_models-1.0.0/src/imandrax_api_models/proto_models/artmsg.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from pydantic import ConfigDict, Field
+
+from ..proto_utils import BaseModel
+
+
+class StorageEntry(BaseModel):
+    model_config = ConfigDict(ser_json_bytes='base64', val_json_bytes='base64')
+
+    key: str = Field(description='the CA store key')
+    value: bytes = Field(description='the stored value')
+
+
+# We tend to generate this using `google.protobuf.json_format.MessageToDict`
+# This converts protobuf bytes to base64 strings
+class Art(BaseModel):
+    model_config = ConfigDict(ser_json_bytes='base64', val_json_bytes='base64')
+
+    kind: str = Field(description='The kind of artifact')
+    data: bytes = Field(description='Serialized data, in twine')
+    api_version: str = Field(
+        description=(
+            'Version of the API. This is mandatory and must match with the imandrax-api'
+            ' library version.'
+        )
+    )
+    storage: list[StorageEntry] = Field(
+        default_factory=lambda: [], description='Additional definitions on the side'
+    )

imandrax_api_models-1.0.0/src/imandrax_api_models/proto_models/error.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import re
+from enum import Enum
+from typing import Self
+
+from pydantic import Field
+
+from ..proto_utils import BaseModel
+from .locs import Location
+
+
+# from https://github.com/imandra-ai/imandrax-api/blob/1a4abb4eb59d9545c6f0af9698956437b5b5dcb8/src/internal/error_data/imandrax_errors.ml
+class ErrorKind(str, Enum):
+    APPLIED_SYMBOL_TYPE_ERR = 'AppliedSymbolTypeErr'
+    CONFIG_ERROR = 'ConfigError'
+    CPTR_GET_OTHER_ERR = 'CptrGetOtherErr'
+    CPTR_NOT_FOUND_IN_STORAGE = 'CptrNotFoundInStorage'
+    GENERIC_USER_ERROR = 'GenericUserError'
+    INVALID_FUN_DEFINITION = 'InvalidFunDefinition'
+    INVALID_QIDENT = 'InvalidQident'
+    INVALID_TYPE_ALIAS = 'InvalidTypeAlias'
+    INVALID_TYPE_DEFINITION = 'InvalidTypeDefinition'
+    INVALID_CNAME = 'InvalidCname'
+    LEVAL_ERROR = 'LevalError'
+    LOWER_CIR_ERROR = 'LowerCirError'
+    LOWER_MIR_ERROR = 'LowerMirError'
+    LOWER_RIR_ERROR = 'LowerRirError'
+    PARSER_NOT_REGISTERED = 'ParserNotRegistered'
+    PATMATCH_ERROR = 'PatmatchError'
+    SYN_TERM_CREATE_ERROR = 'SynTermCreateError'
+    SYNTAX_ATTRIBUTE_ERR = 'SyntaxAttributeErr'
+    SYNTAX_ERR = 'SyntaxErr'
+    SYNTAX_UNSUGAR_ERR = 'SyntaxUnsugarErr'
+    TACTIC_EVAL_ERR = 'TacticEvalErr'
+    TERM_INVALID_SHAPE = 'TermInvalidShape'
+    TERM_MODEL_FIERR = 'TermModelFIErr'
+    THREAD_FUT_FAILURE = 'ThreadFutFailure'
+    THREAD_TIMER_FAILURE = 'ThreadTimerFailure'
+    TY_INFER_INTERNAL_ERROR = 'TyInferInternalError'
+    TYPE_ARITY_MISMATCH = 'TypeArityMismatch'
+    TYPE_CYCLE_DETECTED = 'TypeCycleDetected'
+    TYPE_ERR = 'TypeErr'
+    TYPE_VAR_ALREADY_BOUND = 'TypeVarAlreadyBound'
+    TYPED_SYMBOL_NON_GROUND = 'TypedSymbolNonGround'
+    UID_CONTENT_ADDRESSING_NAME_MISMATCH = 'UidContentAddressingNameMismatch'
+    UID_CONTENT_ADDRESSING_NOT_TEMPORARY = 'UidContentAddressingNotTemporary'
+    UID_NOT_CONTENT_ADDRESSED = 'UidNotContentAddressed'
+    UNKNOWN_BUILTIN_SYMBOL_FOR_UID = 'UnknownBuiltinSymbolForUid'
+    UNKNOWN_TYPE_DEFINITION = 'UnknownTypeDefinition'
+    INTERACTIVE_PROOF_ERR = 'InteractiveProofErr'
+    PROOF_DESER_ERROR = 'ProofDeserError'
+    PROOF_CHECK_ERROR = 'ProofCheckError'
+    INVALID_ANCHOR = 'InvalidAnchor'
+    INDUCT_SCHEMA_ERROR = 'InductSchemaError'
+    UNSUPPORTED = 'Unsupported'
+    LOWER_FOL_ERROR = 'LowerFolError'
+    VALIDATION_ERROR = 'ValidationError'
+    LSP_ERROR = 'LspError'
+    INTERRUPTED = 'Interrupted'
+    REDIS_ERROR = 'RedisError'
+    CIRDECL_NOT_FOUND_IN_STORAGE = 'CIRDeclNotFoundInStorage'
+    SERIALIZATION_ERROR = 'SerializationError'
+    DESERIALIZATION_ERROR = 'DeserializationError'
+    DEBUG_MODE = 'DebugMode'
+    IMPORT_ERROR = 'ImportError'
+    GENERIC_IOERROR = 'GenericIOError'
+    DUNE_ERROR = 'DuneError'
+    RPC_ERROR = 'RpcError'
+    RPC_DESER_ERROR = 'RpcDeserError'
+    RPC_NETWORK_ERROR = 'RpcNetworkError'
+    RPC_TIMEOUT = 'RpcTimeout'
+    AUTH_ERROR = 'AuthError'
+    FILE_EXISTS = 'FileExists'
+    DIRECTORY_CREATION_ERROR = 'DirectoryCreationError'
+    DECOMP_ERROR = 'DecompError'
+    VERSION_MISMATCH_ERROR = 'VersionMismatchError'
+    OH_NO_ERROR = 'OhNoError'
+    DEBOUNCED = 'Debounced'
+
+    @classmethod
+    def from_proto_kind(cls, proto_kind: str) -> Self:
+        kinds = re.findall(r'\{ Kind.name = "(.+)" \}', proto_kind)
+        if len(kinds) != 1:
+            raise ValueError('Unable to parse kind')
+        return cls(kinds[0])
+
+
+class ErrorMessage(BaseModel):
+    msg: str
+    locs: list[Location] = Field(
+        default_factory=lambda: [], description='Locations for this message'
+    )
+    backtrace: str | None = Field(default=None, description='Captured backtrace')
+
+
+class Error(BaseModel):
+    msg: ErrorMessage | None = Field(
+        default=None, description='The toplevel error message'
+    )
+    kind: str = Field(description='A string description of the kind of error')
+    stack: list[ErrorMessage] = Field(
+        default_factory=lambda: [], description='Context for the error'
+    )
+    process: str | None = Field(default=None)

imandrax_api_models-1.0.0/src/imandrax_api_models/proto_models/locs.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from pydantic import Field
+
+from ..proto_utils import BaseModel
+
+
+class Position(BaseModel):
+    line: int
+    col: int
+
+
+class Location(BaseModel):
+    file: str | None = Field(default=None)
+    start: Position | None = Field(default=None)
+    stop: Position | None = Field(default=None)

imandrax_api_models-1.0.0/src/imandrax_api_models/proto_models/session.py

@@ -0,0 +1,27 @@
+from __future__ import annotations
+
+from pydantic import Field
+
+from ..proto_utils import BaseModel
+
+
+class Session(BaseModel):
+    """A session identifier."""
+
+    id: str = Field(description="The session's unique ID (e.g a uuid)")
+
+
+class SessionCreate(BaseModel):
+    """Create a new session."""
+
+    po_check: bool = Field(default=True, description='Do we check Proof Obligations?')
+    api_version: str = Field(description='the API types version (mandatory)')
+
+
+class SessionOpen(BaseModel):
+    """Reconnect to the given session."""
+
+    id: Session | None = Field(
+        default=None, description="The session's unique ID (e.g a uuid)"
+    )
+    api_version: str = Field(description='the API types version (mandatory)')

imandrax_api_models-1.0.0/src/imandrax_api_models/proto_models/simple_api.py

@@ -0,0 +1,411 @@
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any, Literal, Self
+
+from devtools import pformat
+from imandrax_api.lib import (
+    RegionStr,
+    get_region_str_from_decomp_artifact,
+)
+from pydantic import (
+    Field,
+    TypeAdapter,
+    field_validator,
+    model_validator,
+)
+
+from ..proto_utils import BaseModel
+from .artmsg import Art
+from .error import Error
+from .session import Session
+from .task import Origin, Task
+from .utils import Empty, StringMsg
+
+
+class SessionCreateReq(BaseModel):
+    api_version: str = Field(description='the API types version (mandatory)')
+
+
+class LiftBool(Enum):
+    Default = 0
+    NestedEqualities = 1
+    Equalities = 2
+    All = 3
+
+
+class DecomposeReq(BaseModel):
+    session: Session | None = Field(default=None)
+    name: str = Field(description='name of function to decompose')
+    assuming: str | None = Field(
+        default=None, description='name of side condition function'
+    )
+    basis: list[str]
+    rule_specs: list[str]
+    prune: bool
+    ctx_simp: bool | None = Field(default=None)
+    lift_bool: LiftBool | None = Field(default=None)
+    str_: bool = Field(default=True, alias='str')
+    timeout: int | None = Field(default=None)
+
+
+class DecomposeResProto(BaseModel):
+    artifact: Art | None = Field(default=None)
+    err: Empty | None = Field(default=None)
+    errors: list[Error] = Field(default_factory=lambda: [])
+    task: Task | None = Field(default=None)
+
+    @model_validator(mode='after')
+    def one_of_res(self) -> Self:
+        if (self.artifact is None) == (self.err is None):
+            raise ValueError('One of artifact or err must be set')
+        return self
+
+
+class string_kv(BaseModel):
+    k: str
+    v: str
+
+
+class DecomposeRes(DecomposeResProto):
+    """Result of a decomposition."""
+
+    regions_str: list[RegionStr] | None = Field(
+        default=None, description="None if there's decomposition error"
+    )
+
+    @model_validator(mode='after')
+    def unwrap_region_str(self) -> Self:
+        if self.regions_str is not None:
+            return self
+        elif self.errors:
+            return self
+        else:
+            assert self.artifact is not None, 'artifact must be present when no errors'
+            regions_str = get_region_str_from_decomp_artifact(
+                data=self.artifact.data, kind=self.artifact.kind
+            )
+            return self.model_copy(update={'regions_str': regions_str})
+
+    def __repr__(self) -> str:
+        return pformat(self)
+
+    @property
+    def iml_test_cases(self) -> list[dict[str, Any]]:
+        """
+        Format region strings as test cases.
+
+        Eg: [
+            {"args": {"x": "1", "y": "2"}, "expected_output": "3"},
+            {"args": {"x": "3", "y": "4"}, "expected_output": "7"},
+        ].
+        """
+        if not self.regions_str:
+            return []
+        test_cases: list[dict[str, Any]] = []
+        for region_str in self.regions_str:
+            if (model_eval_str := region_str.model_eval_str) is None:
+                continue
+            test_cases.append(
+                {'args': region_str.model_str, 'expected_output': model_eval_str}
+            )
+        return test_cases
+
+    @property
+    def test_docstrs(self) -> list[str]:
+        docstrs: list[str] = []
+        if not self.regions_str:
+            return docstrs
+        for region_str in self.regions_str:
+            s = ''
+            if region_str.constraints_str:
+                s += 'Constraints:\n'
+                for c in region_str.constraints_str:
+                    s += f'    - `{c}`\n'
+            if region_str.invariant_str:
+                s += 'Invariant:\n'
+                s += f'    - `{region_str.invariant_str}`\n'
+            docstrs.append(s)
+        return docstrs
+
+
+class EvalSrcReq(BaseModel):
+    session: Session | None = Field(default=None)
+    src: str = Field(description='source code to evaluate')
+    async_only: bool | None = Field(
+        default=None,
+        description='if true, do not wait for tasks results, only return the task list '
+        'and not the task results. Use `get_artifact` to get the results.',
+    )
+
+
+class EvalOutput(BaseModel):
+    """Output of an `eval` statement."""
+
+    success: bool
+    value_as_ocaml: str | None = Field(
+        default=None, description='result as a OCaml value, if any'
+    )
+    errors: list[Error] = Field(default_factory=lambda: [])
+
+
+class EvalRes(BaseModel):
+    success: bool = Field()
+    messages: list[str] = Field(
+        default_factory=lambda: [], description='"normal" messages'
+    )
+    errors: list[Error] = Field(
+        default_factory=lambda: [], description='akin to stderr'
+    )
+
+    # All tasks started during eval
+    tasks: list[Task] = Field(
+        default_factory=lambda: [], description='all tasks started during eval'
+    )
+    po_results: list[PO_Res] = Field(default_factory=lambda: [])
+    eval_results: list[EvalOutput] = Field(default_factory=lambda: [])
+    decomp_results: list[DecomposeRes] = Field(default_factory=lambda: [])
+
+    def __repr__(self) -> str:
+        return pformat(self, indent=2)
+
+    @property
+    def po_errors(self) -> list[Error]:
+        return [err for po_res in self.po_results for err in po_res.errors]
+
+    @property
+    def all_errors(self) -> list[Error]:
+        """
+        Non-proof-obligation errors and proof-obligation errors.
+
+        Non-proof-obligation errors always come first
+        """
+        return self.errors + self.po_errors
+
+    @property
+    def has_errors(self) -> bool:
+        return len(self.all_errors) > 0
+
+
+class VerifySrcReq(BaseModel):
+    session: Session | None = Field(default=None)
+    src: str = Field(description='source code')
+    hints: str | None = Field(default=None)
+
+
+class VerifyNameReq(BaseModel):
+    session: Session | None = Field(default=None)
+    name: str = Field(description='name of the predicate to verify')
+    hints: str | None = Field(default=None)
+
+
+class InstanceSrcReq(BaseModel):
+    session: Session | None = Field(default=None)
+    src: str = Field(description='source code')
+    hints: str | None = Field(default=None)
+
+
+class InstanceNameReq(BaseModel):
+    session: Session | None = Field(default=None)
+    name: str = Field(description='name of the predicate to verify')
+    hints: str | None = Field(default=None)
+
+
+class Proved(BaseModel):
+    proof_pp: str | None = Field(default=None)
+
+
+class Verified_upto(BaseModel):
+    msg: str | None = Field(default=None)
+
+
+class Unsat(BaseModel):
+    proof_pp: str | None = Field(default=None)
+
+
+class ModelType(Enum):
+    Counter_example = 'Counter_example'
+    Instance = 'Instance'
+
+
+class Model(BaseModel):
+    m_type: ModelType  # NOTE: proto file has this but it's not returned?
+    src: str = Field(description='iml source code for the model')
+    artifact: Art | None = Field(default=None, description='the model as an artifact')
+
+
+class Refuted(BaseModel):
+    model: Model | None = Field(default=None)
+
+
+class Sat(BaseModel):
+    model: Model | None = Field(default=None)
+
+
+class CounterSat(BaseModel):
+    model: Model | None = Field(default=None)
+
+
+class PO_Res(BaseModel):
+    unknown: StringMsg | None = Field(default=None)
+    err: Empty | None = Field(default=None)
+    proof: Proved | None = Field(default=None)
+    instance: CounterSat | None = Field(default=None)
+    verified_upto: Verified_upto | None = Field(default=None)
+
+    errors: list[Error] = Field(default_factory=lambda: [])
+    task: Task | None = Field(default=None, description='the ID of the task')
+    origin: Origin | None = Field(
+        default=None, description='where did the task originate?'
+    )
+
+    @model_validator(mode='after')
+    def one_of_res(self) -> Self:
+        sum_of_res = sum(
+            1
+            for r in [
+                self.unknown,
+                self.err,
+                self.proof,
+                self.instance,
+                self.verified_upto,
+            ]
+            if r is not None
+        )
+        if sum_of_res != 1:
+            raise ValueError(
+                'Exactly one of unknown, err, proof, instance, verified_upto must be '
+                'set'
+            )
+        return self
+
+
+class VerifyRes(BaseModel):
+    unknown: StringMsg | None = Field(default=None)
+    err: Empty | None = Field(default=None)
+    proved: Proved | None = Field(default=None)
+    refuted: Refuted | None = Field(default=None)
+    verified_upto: Verified_upto | None = Field(default=None)
+
+    errors: list[Error] = Field(default_factory=lambda: [])
+    task: Task | None = Field(default=None, description='the ID of the task')
+
+    @property
+    def res_type(
+        self,
+    ) -> Literal['unknown', 'err', 'proved', 'refuted', 'verified_upto']:
+        if self.unknown is not None:
+            return 'unknown'
+        elif self.err is not None:
+            return 'err'
+        elif self.proved is not None:
+            return 'proved'
+        elif self.refuted is not None:
+            return 'refuted'
+        elif self.verified_upto is not None:
+            return 'verified_upto'
+        else:
+            raise AssertionError('Never')
+
+    @property
+    def res(self) -> StringMsg | Empty | Proved | Refuted | Verified_upto:
+        if self.unknown is not None:
+            return self.unknown
+        elif self.err is not None:
+            return self.err
+        elif self.proved is not None:
+            return self.proved
+        elif self.refuted is not None:
+            return self.refuted
+        elif self.verified_upto is not None:
+            return self.verified_upto
+        else:
+            raise AssertionError('Never')
+
+    @model_validator(mode='after')
+    def one_of_res(self) -> Self:
+        sum_of_res = sum(
+            1
+            for r in [
+                self.unknown,
+                self.err,
+                self.proved,
+                self.refuted,
+                self.verified_upto,
+            ]
+            if r is not None
+        )
+        if sum_of_res != 1:
+            raise ValueError(
+                'Exactly one of unknown, err, proved, refuted, verified_upto must be '
+                'set'
+            )
+        return self
+
+
+class InstanceRes(BaseModel):
+    unknown: StringMsg | None = Field(default=None)
+    err: Empty | None = Field(default=None)
+    unsat: Unsat | None = Field(default=None)
+    sat: Sat | None = Field(default=None)
+
+    errors: list[Error] = Field(default_factory=lambda: [])
+    task: Task | None = Field(default=None, description='the ID of the task')
+
+    @model_validator(mode='after')
+    def one_of_res(self) -> Self:
+        sum_of_res = sum(
+            1 for r in [self.unknown, self.err, self.unsat, self.sat] if r is not None
+        )
+        if sum_of_res != 1:
+            raise ValueError('Exactly one of unknown, err, unsat, sat must be set')
+        return self
+
+
+class TypecheckReq(BaseModel):
+    session: Session | None = Field(default=None)
+    src: str = Field(description='source code to evaluate')
+
+
+class TypecheckResProto(BaseModel):
+    success: bool
+    types: str = Field(description='JSON string of inferred types')
+    errors: list[Error] = Field(default_factory=lambda: [])
+
+
+class InferredType(BaseModel):
+    name: str
+    ty: str = Field(description='inferred type')
+    line: int = Field(description='line number')
+    column: int = Field(description='column number')
+
+
+InferredTypes = TypeAdapter(list[InferredType])
+
+
+class TypecheckRes(TypecheckResProto):
+    types: list[InferredType] = Field(description='Parsed inferred types')  # type: ignore[assignment]
+
+    @field_validator('types', mode='before')
+    @classmethod
+    def validate_types(cls, v: str | list[InferredType]) -> list[InferredType]:
+        if isinstance(v, str):
+            # Parse JSON string into list of dicts and validate with pydantic
+            types_list = InferredTypes.validate_json(v)
+            return types_list
+        return v
+
+
+class OneshotReq(BaseModel):
+    input: str = Field(description='some iml code')
+    timeout: float | None = Field(default=None)
+
+
+class OneshotRes(BaseModel):
+    class Stats(BaseModel):
+        time: float
+
+    results: list[str] = Field(default_factory=list)
+    errors: list[str] = Field(default_factory=list)
+    stats: Stats | None = Field(default=None)
+    detailed_results: list[str] = Field(default_factory=list)

imandrax_api_models-1.0.0/src/imandrax_api_models/proto_models/task.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from enum import Enum
+
+from pydantic import Field
+
+from ..proto_utils import BaseModel
+
+
+class TaskKind(Enum):
+    TASK_UNSPECIFIED = 'TASK_UNSPECIFIED'
+    TASK_EVAL = 'TASK_EVAL'
+    TASK_CHECK_PO = 'TASK_CHECK_PO'
+    TASK_PROOF_CHECK = 'TASK_PROOF_CHECK'
+    TASK_DECOMP = 'TASK_DECOMP'
+
+
+class TaskID(BaseModel):
+    id: str = Field(description='The task identifier')
+
+
+class Task(BaseModel):
+    id: TaskID | None = Field(default=None)
+    kind: TaskKind
+
+
+class Origin(BaseModel):
+    from_sym: str = Field(description='Symbol from which the task originated')
+    count: int = Field(description='A counter for tasks for this symbol')

imandrax_api_models-1.0.0/src/imandrax_api_models/proto_models/utils.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from ..proto_utils import BaseModel
+
+
+class Empty(BaseModel):
+    """Void type, used for messages without arguments or return value."""
+
+    pass
+
+
+class StringMsg(BaseModel):
+    msg: str

imandrax_api_models-1.0.0/src/imandrax_api_models/proto_utils.py

@@ -0,0 +1,21 @@
+from typing import Any
+
+from google.protobuf.json_format import MessageToDict
+from google.protobuf.message import Message
+from pydantic import BaseModel as PydanticBaseModel, model_validator
+
+
+def proto_to_dict(proto_obj: Message) -> dict[Any, Any]:
+    return MessageToDict(
+        proto_obj,
+        preserving_proto_field_name=True,
+        always_print_fields_with_no_presence=True,
+    )
+
+
+class BaseModel(PydanticBaseModel):
+    @model_validator(mode='before')
+    def validate_proto(cls, v: Any) -> dict[Any, Any]:
+        if isinstance(v, Message):
+            return proto_to_dict(v)
+        return v