itf-py 0.1.0__tar.gz

itf_py-0.1.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.3
+Name: itf-py
+Version: 0.1.0
+Summary: Python library to parse and emit Apalache ITF traces
+Author: Igor Konnov
+Author-email: igor@konnov.phd
+Requires-Python: >=3.12,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Project-URL: Homepage, https://github.com/konnov/itf-py
+Description-Content-Type: text/markdown
+
+# ITF-py: Parser and Encoder for the ITF Trace Format
+
+Python library to parse and emit Apalache ITF traces. Refer to
+[ADR015](https://apalache-mc.org/docs/adr/015adr-trace.html) for the format. ITF
+traces are emitted by [Apalache](https://github.com/apalache-mc/apalache) and
+[Quint](https://github.com/informalsystems/quint).
+
+**No fluff.** We keep this library intentionally minimalistic. You can use it in
+your projects without worrying about pulling dozens of dependencies.

itf_py-0.1.0/README.md

@@ -0,0 +1,9 @@
+# ITF-py: Parser and Encoder for the ITF Trace Format
+
+Python library to parse and emit Apalache ITF traces. Refer to
+[ADR015](https://apalache-mc.org/docs/adr/015adr-trace.html) for the format. ITF
+traces are emitted by [Apalache](https://github.com/apalache-mc/apalache) and
+[Quint](https://github.com/informalsystems/quint).
+
+**No fluff.** We keep this library intentionally minimalistic. You can use it in
+your projects without worrying about pulling dozens of dependencies.

itf_py-0.1.0/pyproject.toml

@@ -0,0 +1,83 @@
+[tool.poetry]
+name = "itf-py"
+version = "0.1.0"
+description = "Python library to parse and emit Apalache ITF traces"
+homepage = "https://github.com/konnov/itf-py"
+authors = ["Igor Konnov <igor@konnov.phd>"]
+readme = "README.md"
+packages = [{include = "itf_py", from = "src"}]
+
+[tool.poetry.dependencies]
+python = "^3.12"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.0.0"
+pytest-cov = "^5.0.0"
+black = "^24.0.0"
+isort = "^5.13.0"
+flake8 = "^7.0.0"
+mypy = "^1.8.0"
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 88
+target-version = ['py312']
+include = '\.pyi?$'
+extend-exclude = '''
+/(
+  # directories
+  \.eggs
+  | \.git
+  | \.hg
+  | \.mypy_cache
+  | \.tox
+  | \.venv
+  | build
+  | dist
+)/
+'''
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+line_length = 88
+known_first_party = ["itf_py"]
+
+[tool.mypy]
+python_version = "3.12"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+disallow_incomplete_defs = true
+check_untyped_defs = true
+disallow_untyped_decorators = true
+no_implicit_optional = true
+warn_redundant_casts = true
+warn_unused_ignores = true
+warn_no_return = true
+warn_unreachable = true
+strict_equality = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = "--strict-markers --strict-config --verbose"
+
+[tool.flake8]
+max-line-length = 88
+extend-ignore = ["E203", "W503"]
+exclude = [
+    ".git",
+    "__pycache__",
+    ".venv",
+    ".eggs",
+    "*.egg",
+    "dist",
+    "build",
+]

itf_py-0.1.0/src/itf_py/__init__.py

@@ -0,0 +1,10 @@
+"""
+Python library to parse and emit Apalache ITF traces.
+"""
+
+from .itf import ITFState
+
+__version__ = "0.1.0"
+__all__ = [
+    "ITFState",
+]

itf_py-0.1.0/src/itf_py/itf.py

@@ -0,0 +1,107 @@
+from dataclasses import dataclass
+from types import SimpleNamespace
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class ITFState:
+    """A single state in an ITF trace as a Python object."""
+
+    meta: Dict[str, Any]
+    values: Dict[str, Any]
+
+
+@dataclass
+class ITFTrace:
+    """An ITF trace as a Python object."""
+
+    meta: Dict[str, Any]
+    params: List[str]
+    vars: List[str]
+    states: List[ITFState]
+    loop: Optional[int]
+
+
+@dataclass
+class ITFUnserializable:
+    """A placeholder for unserializable values."""
+
+    value: str
+
+
+def value_from_json(val: Any) -> Any:
+    """Deserialize a Python value from JSON"""
+    if isinstance(val, dict):
+        if "#bigint" in val:
+            return int(val["#bigint"])
+        elif "#tup" in val:
+            return tuple(value_from_json(v) for v in val["#tup"])
+        elif "#set" in val:
+            return frozenset(value_from_json(v) for v in val["#set"])
+        elif "#map" in val:
+            return {value_from_json(k): value_from_json(v) for (k, v) in val["#map"]}
+        elif "#unserializable" in val:
+            return ITFUnserializable(value=val["#unserializable"])
+        else:
+            return SimpleNamespace(**{k: value_from_json(v) for k, v in val.items()})
+    elif isinstance(val, list):
+        return [value_from_json(v) for v in val]
+    else:
+        return val  # int, str, bool
+
+
+def value_to_json(val: Any) -> Any:
+    """Serialize a Python value into JSON"""
+    if isinstance(val, bool):
+        return val
+    elif isinstance(val, int):
+        return {"#bigint": str(val)}
+    elif isinstance(val, tuple):
+        return {"#tup": [value_to_json(v) for v in val]}
+    elif isinstance(val, frozenset):
+        return {"#set": [value_to_json(v) for v in val]}
+    elif isinstance(val, dict):
+        return {"#map": [[value_to_json(k), value_to_json(v)] for k, v in val.items()]}
+    elif isinstance(val, list):
+        return [value_to_json(v) for v in val]
+    elif hasattr(val, "__dict__"):
+        return {k: value_to_json(v) for k, v in val.__dict__.items()}
+    elif isinstance(val, str):
+        return val
+    else:
+        return ITFUnserializable(value=str(val))
+
+
+def state_from_json(raw_state: Dict[str, Any]) -> ITFState:
+    """Deserialize a single ITFState from JSON"""
+    state_meta = raw_state["#meta"] if "#meta" in raw_state else {}
+    values = {k: value_from_json(v) for k, v in raw_state.items() if k != "#meta"}
+    return ITFState(meta=state_meta, values=values)
+
+
+def state_to_json(state: ITFState) -> Dict[str, Any]:
+    """Serialize a single ITFState to JSON"""
+    result = {"#meta": state.meta}
+    for k, v in state.values.items():
+        result[k] = value_to_json(v)
+    return result
+
+
+def trace_from_json(data: Dict[str, Any]) -> ITFTrace:
+    """Deserialize an ITFTrace from JSON"""
+    meta = data["#meta"] if "#meta" in data else {}
+    params = data.get("params", [])
+    vars_ = data["vars"]
+    loop = data.get("loop", None)
+    states = [state_from_json(s) for s in data["states"]]
+    return ITFTrace(meta=meta, params=params, vars=vars_, states=states, loop=loop)
+
+
+def trace_to_json(trace: ITFTrace) -> Dict[str, Any]:
+    """Serialize an ITFTrace to JSON"""
+    result: Dict[str, Any] = {"#meta": trace.meta}
+    result["params"] = trace.params
+    result["vars"] = trace.vars
+    result["loop"] = trace.loop
+    result["states"] = [state_to_json(s) for s in trace.states]
+    return result