vnnlib 1.0.0__cp311-cp311-macosx_10_15_x86_64.whl

vnnlib/__init__.py

@@ -0,0 +1,76 @@
+"""
+VNNLib Python Bindings
+
+Modern Python bindings for the VNNLib verification language parser.
+Built with pybind11 for direct access to the BNFC-generated C++ AST.
+
+Basic Usage:
+    import vnnlib
+    
+    # Parse a VNNLIB file
+    query = vnnlib.parse_query_file("path/to/file.vnnlib")
+    
+    # Access networks and constraints
+    for network in query.networks:
+        print(f"Network: {network.name}")
+        
+    # Use compatibility module for reachability format
+    import vnnlib.compat
+    cases = vnnlib.compat.transform(query)
+"""
+
+from ._core import (
+    # Parsing functions
+    parse_query_file, parse_query_string,
+    
+    # Core AST node types
+    Query, Network, Assertion,
+    InputDefinition, OutputDefinition, HiddenDefinition,
+    Version,
+    
+    # Expression types
+    ArithExpr, BoolExpr, 
+    Var, Literal, Float, Int, Negate, Plus, Minus, Multiply,
+    Comparison, GreaterThan, GreaterEqual, LessThan, LessEqual, Equal, NotEqual,
+    Connective, And, Or,
+    
+    # Linear arithmetic
+    LinearArithExpr, Term,
+    
+    # Enums and data types
+    DType, SymbolKind,
+    
+    # Exceptions
+    VNNLibException,
+)
+
+# Module metadata
+__version__ = "1.0.0-dev"
+__author__ = "Allen Antony" 
+__description__ = "Python bindings for VNNLib verification language"
+__url__ = "https://github.com/VNNLIB/VNNLIB-Standard"
+
+__all__ = [
+    # Parsing functions
+    "parse_query_file", "parse_query_string",
+    
+    # Core AST nodes
+    "Query", "Network", "Assertion", 
+    "InputDefinition", "OutputDefinition", "HiddenDefinition",
+    "Version",
+    
+    # Expression types  
+    "ArithExpr", "BoolExpr",
+    "Var", "Literal", "Float", "Int", "Negate", "Plus", "Minus", "Multiply",
+    "Comparison", "GreaterThan", "GreaterEqual", "LessThan", "LessEqual", "Equal", "NotEqual",
+    "Connective", "And", "Or",
+    
+    # Linear arithmetic
+    "LinearArithExpr", "Term",
+    
+    # Enums and data types
+    "DType", "SymbolKind",
+    
+    # Exceptions
+    "VNNLibException",
+]

vnnlib/__init__.pyi

@@ -0,0 +1,3 @@
+"""Type stubs for VNNLib Python bindings"""
+
+from ._core import *

vnnlib/_core.cpp

@@ -0,0 +1,287 @@
+#include <pybind11/pybind11.h>
+#include <pybind11/stl.h>
+#include <memory>
+#include <exception>
+#include <string>
+#include <vector>
+
+#include "VNNLib.h"                
+#include "TypeChecker.h"     
+#include "TypedAST.h"     
+#include "TypedBuilder.h"
+#include "LinearArithExpr.h"
+#include "DNFConverter.h"
+#include "CompatTransformer.h"
+#include "Error.hpp"
+
+namespace py = pybind11;
+
+PYBIND11_MODULE(_core, m) {
+	m.doc() = "Python bindings for VNNLib parsing and AST traversal";
+
+	py::register_exception<VNNLibException>(m, "VNNLibException");
+
+	// Helper Types
+	py::enum_<TDataType>(m, "DType")
+		.value("Real", TDataType::Real)
+		.value("F16", TDataType::F16).value("F32", TDataType::F32).value("F64", TDataType::F64).value("BF16", TDataType::BF16)
+		.value("F8E4M3FN", TDataType::F8E4M3FN).value("F8E5M2", TDataType::F8E5M2)
+		.value("F8E4M3FNUZ", TDataType::F8E4M3FNUZ).value("F8E5M2FNUZ", TDataType::F8E5M2FNUZ)
+		.value("F4E2M1", TDataType::F4E2M1)
+		.value("I8", TDataType::I8).value("I16", TDataType::I16).value("I32", TDataType::I32).value("I64", TDataType::I64)
+		.value("U8", TDataType::U8).value("U16", TDataType::U16).value("U32", TDataType::U32).value("U64", TDataType::U64)
+		.value("C64", TDataType::C64).value("C128", TDataType::C128)
+		.value("Bool", TDataType::Bool).value("String", TDataType::String)
+		.value("Unknown", TDataType::Unknown)
+		.value("NegativeIntConstant", TDataType::NegativeIntConstant)
+		.value("PositiveIntConstant", TDataType::PositiveIntConstant)
+		.value("FloatConstant", TDataType::FloatConstant);
+
+	py::enum_<SymbolKind>(m, "SymbolKind")
+		.value("Input", SymbolKind::Input)
+		.value("Hidden", SymbolKind::Hidden)
+		.value("Output", SymbolKind::Output)
+		.value("Unknown", SymbolKind::Unknown);
+
+	py::class_<TNode>(m, "Node")
+		.def("__str__", [](const TNode& n){ return n.toString(); })
+		.def("children", [](py::object self){ 
+			const TNode& n = self.cast<const TNode&>();
+			std::vector<const TNode*> children;
+			n.children(children);
+			py::tuple out(children.size());
+
+			for (int i = 0; i < children.size(); ++i) {
+				out[i] = py::cast(children[i], py::return_value_policy::reference_internal, self);
+			}
+			return out;
+		});
+
+	// --- LinearArithExpr ---
+	py::class_<LinearArithExpr::Term>(m, "Term")
+		.def_property_readonly("coeff",    [](const LinearArithExpr::Term& t){ return t.coeff; })
+		.def_property_readonly("var", [](const LinearArithExpr::Term& t){ return t.var; }, py::return_value_policy::reference_internal)
+		.def_property_readonly("var_name", [](const LinearArithExpr::Term& t){ return t.varName; });
+
+	py::class_<LinearArithExpr>(m, "LinearArithExpr")
+		.def_property_readonly("terms", [](const LinearArithExpr& e){ return e.getTerms(); })
+		.def_property_readonly("constant", [](const LinearArithExpr& e){ return e.getConstant(); });
+
+	// --- Arithmetic Operations --- 
+	py::class_<TArithExpr, TNode>(m, "ArithExpr")
+		.def_property_readonly("dtype", [](const TArithExpr& e){ return e.dtype; })
+		.def("to_linear_expr", [](const TArithExpr& e){
+			auto lin_expr = linearize(&e);
+			return py::cast(lin_expr.release(), py::return_value_policy::take_ownership);
+		});
+
+	py::class_<TVarExpr, TArithExpr>(m, "Var")
+		.def_property_readonly("name",      [](const TVarExpr& v){ return v.symbol ? v.symbol->name : std::string{}; })
+		.def_property_readonly("onnx_name", [](const TVarExpr& v)->py::object{
+			if (v.symbol->onnxName.empty()) return py::none();
+			return py::str(v.symbol->onnxName);
+		})
+		.def_property_readonly("dtype",       [](const TVarExpr& v){ return v.symbol->dtype; })
+		.def_property_readonly("shape",       [](const TVarExpr& v){ return v.symbol->shape; })
+		.def_property_readonly("kind",        [](const TVarExpr& v){ return v.symbol->kind; })
+		.def_property_readonly("network_name",[](const TVarExpr& v){ return v.symbol->networkName; })
+		.def_property_readonly("indices",     [](const TVarExpr& v){ return v.indices; })
+		.def_property_readonly("line",        [](const TVarExpr& v){ return v.line; });
+
+	py::class_<TLiteral, TArithExpr>(m, "Literal")
+		.def_property_readonly("lexeme", [](const TLiteral& e){ return e.lexeme; })
+		.def_property_readonly("line",   [](const TLiteral& e){ return e.line; });
+
+	py::class_<TFloat, TLiteral>(m, "Float")
+		.def_property_readonly("value", [](const TFloat& n){ return n.value; });
+
+	py::class_<TInt, TLiteral>(m, "Int")
+		.def_property_readonly("value", [](const TInt& n){ return n.value; });
+
+	py::class_<TNegate, TArithExpr>(m, "Negate")
+		.def_property_readonly("expr", [](const TNegate& n){ return n.expr.get(); }, py::return_value_policy::reference_internal);
+
+	py::class_<TPlus, TArithExpr>(m, "Plus")
+	.def_property_readonly("args", [](const TPlus& n){
+		py::tuple args_tuple(n.args.size());
+		for (size_t i = 0; i < n.args.size(); ++i)
+			args_tuple[i] = py::cast(n.args[i].get(), py::return_value_policy::reference_internal, py::cast(&n));
+		return args_tuple;
+	});
+
+	py::class_<TMinus, TArithExpr>(m, "Minus")
+	.def_property_readonly("head", [](const TMinus& n){ return n.head.get(); }, py::return_value_policy::reference_internal)
+	.def_property_readonly("rest", [](const TMinus& n){
+		py::tuple rest_tuple(n.rest.size());
+		for (size_t i = 0; i < n.rest.size(); ++i)
+			rest_tuple[i] = py::cast(n.rest[i].get(), py::return_value_policy::reference_internal, py::cast(&n));
+		return rest_tuple;
+	});
+
+	py::class_<TMultiply, TArithExpr>(m, "Multiply")
+	.def_property_readonly("args", [](const TMultiply& n){
+		py::tuple args_tuple(n.args.size());
+		for (size_t i = 0; i < n.args.size(); ++i)
+			args_tuple[i] = py::cast(n.args[i].get(), py::return_value_policy::reference_internal, py::cast(&n));
+		return args_tuple;
+	});
+
+  	// ---------- Boolean Operations ----------
+	py::class_<TBoolExpr, TNode>(m, "BoolExpr")
+		.def("to_dnf", [](const TBoolExpr& e){
+			DNF dnf = toDNF(&e);
+			py::list py_dnf;
+
+			for (size_t i = 0; i < dnf.size(); ++i) {
+				auto& clause = dnf[i];
+				py::list py_clause;
+				for (auto* lit : clause) {
+					py_clause.append(py::cast(lit, py::return_value_policy::reference_internal, py::cast(&e)));
+				}
+				py_dnf.append(py_clause);
+			}
+			return py_dnf;
+		});
+
+	py::class_<TCompare, TBoolExpr>(m, "Comparison")
+		.def_property_readonly("lhs", [](const TCompare& n){ return n.lhs.get(); }, py::return_value_policy::reference_internal)
+		.def_property_readonly("rhs", [](const TCompare& n){ return n.rhs.get(); }, py::return_value_policy::reference_internal);
+
+	py::class_<TGreaterThan, TCompare>(m, "GreaterThan");
+	py::class_<TEqual, TCompare>(m, "Equal");
+	py::class_<TLessThan, TCompare>(m, "LessThan");
+	py::class_<TGreaterEqual, TCompare>(m, "GreaterEqual");
+	py::class_<TLessEqual, TCompare>(m, "LessEqual");
+	py::class_<TNotEqual, TCompare>(m, "NotEqual");
+
+	py::class_<TConnective, TBoolExpr>(m, "Connective")
+		.def_property_readonly("args", [](const TConnective& n){
+			py::tuple args_tuple(n.args.size());
+			for (size_t i = 0; i < n.args.size(); ++i)
+				args_tuple[i] = py::cast(n.args[i].get(), py::return_value_policy::reference_internal, py::cast(&n));
+			return args_tuple;
+		});
+
+	py::class_<TAnd, TConnective>(m, "And");
+	py::class_<TOr, TConnective>(m, "Or");
+
+	// --- Assertion ---
+	py::class_<TAssertion, TNode>(m, "Assertion")
+		.def_property_readonly("expr", [](const TAssertion& a){ return a.cond.get(); }, py::return_value_policy::reference_internal);
+	
+	// --- Definitions ---
+	py::class_<TInputDefinition, TNode>(m, "InputDefinition")
+		.def_property_readonly("name", [](const TInputDefinition& d){ return d.symbol ? d.symbol->name : std::string{}; })
+		.def_property_readonly("onnx_name", [](const TInputDefinition& d)->py::object{
+			if (d.symbol->onnxName.empty()) return py::none();
+			return py::str(d.symbol->onnxName);
+		})
+		.def_property_readonly("dtype", [](const TInputDefinition& d){ return d.symbol ? d.symbol->dtype : TDataType::Unknown; })
+		.def_property_readonly("shape", [](const TInputDefinition& d){ return d.symbol ? d.symbol->shape : Shape{}; })
+		.def_property_readonly("kind",  [](const TInputDefinition& d){ return d.symbol ? d.symbol->kind : SymbolKind::Unknown; })
+		.def_property_readonly("network_name", [](const TInputDefinition& d){ return d.symbol ? d.symbol->networkName : std::string{}; });
+
+	py::class_<THiddenDefinition, TNode>(m, "HiddenDefinition")
+		.def_property_readonly("name", [](const THiddenDefinition& d){ return d.symbol ? d.symbol->name : std::string{}; })
+		.def_property_readonly("onnx_name", [](const THiddenDefinition& d)->py::object{
+			if (d.symbol->onnxName.empty()) return py::none();
+			return py::str(d.symbol->onnxName);
+		})
+		.def_property_readonly("dtype", [](const THiddenDefinition& d){ return d.symbol ? d.symbol->dtype : TDataType::Unknown; })
+		.def_property_readonly("shape", [](const THiddenDefinition& d){ return d.symbol ? d.symbol->shape : Shape{}; })
+		.def_property_readonly("kind",  [](const THiddenDefinition& d){ return d.symbol ? d.symbol->kind : SymbolKind::Unknown; })
+		.def_property_readonly("network_name", [](const THiddenDefinition& d){ return d.symbol ? d.symbol->networkName : std::string{}; });
+
+	py::class_<TOutputDefinition, TNode>(m, "OutputDefinition")
+		.def_property_readonly("name", [](const TOutputDefinition& d){ return d.symbol ? d.symbol->name : std::string{}; })
+		.def_property_readonly("onnx_name", [](const TOutputDefinition& d)->py::object{
+			if (d.symbol->onnxName.empty()) return py::none();
+			return py::str(d.symbol->onnxName);
+		})
+		.def_property_readonly("dtype", [](const TOutputDefinition& d){ return d.symbol ? d.symbol->dtype : TDataType::Unknown; })
+		.def_property_readonly("shape", [](const TOutputDefinition& d){ return d.symbol ? d.symbol->shape : Shape{}; })
+		.def_property_readonly("kind",  [](const TOutputDefinition& d){ return d.symbol ? d.symbol->kind : SymbolKind::Unknown; })
+		.def_property_readonly("network_name", [](const TOutputDefinition& d){ return d.symbol ? d.symbol->networkName : std::string{}; });
+
+	// --- Network ---
+	py::class_<TNetworkDefinition, TNode>(m, "Network")
+	.def_property_readonly("name", [](const TNetworkDefinition& n){ return n.networkName; })
+	.def_property_readonly("isometric_to", [](const TNetworkDefinition& n){ return n.isometricTo; })
+	.def_property_readonly("equal_to", [](const TNetworkDefinition& n){ return n.equalTo; })
+	.def_property_readonly("inputs", [](const TNetworkDefinition& n){
+		py::tuple input_tuple(n.inputs.size());
+		for (size_t i = 0; i < n.inputs.size(); ++i)
+			input_tuple[i] = py::cast(n.inputs[i].get(), py::return_value_policy::reference_internal, py::cast(&n));
+		return input_tuple;
+	})
+	.def_property_readonly("hidden", [](const TNetworkDefinition& n){
+		py::tuple hidden_tuple(n.hidden.size());
+		for (size_t i = 0; i < n.hidden.size(); ++i)
+			hidden_tuple[i] = py::cast(n.hidden[i].get(), py::return_value_policy::reference_internal, py::cast(&n));
+		return hidden_tuple;
+	})
+	.def_property_readonly("outputs", [](const TNetworkDefinition& n){
+		py::tuple output_tuple(n.outputs.size());
+		for (size_t i = 0; i < n.outputs.size(); ++i)
+			output_tuple[i] = py::cast(n.outputs[i].get(), py::return_value_policy::reference_internal, py::cast(&n));
+		return output_tuple;
+	});
+
+	// --- Version ---
+	py::class_<TVersion, TNode>(m, "Version")
+		.def_property_readonly("major", [](const TVersion& v){ return v.major; })
+		.def_property_readonly("minor", [](const TVersion& v){ return v.minor; });
+
+	// --- Query ---
+	py::class_<TQuery, TNode>(m, "Query")
+    .def_property_readonly("networks", [](const TQuery& q){
+		py::tuple network_tuple(q.networks.size());
+		for (size_t i = 0; i < q.networks.size(); ++i)
+			network_tuple[i] = py::cast(q.networks[i].get(), py::return_value_policy::reference_internal, py::cast(&q));
+		return network_tuple;
+	})
+    .def_property_readonly("assertions", [](const TQuery& q){
+		py::tuple assertion_tuple(q.assertions.size());
+		for (size_t i = 0; i < q.assertions.size(); ++i)
+			assertion_tuple[i] = py::cast(q.assertions[i].get(), py::return_value_policy::reference_internal, py::cast(&q));
+		return assertion_tuple;
+	});
+
+	// --- CompatTransformer ---
+	py::class_<Polytope>(m, "Polytope")
+		.def_property_readonly("coeff_matrix", [](const Polytope& p){ return p.coeffMatrix; })
+		.def_property_readonly("rhs", [](const Polytope& p){ return p.rhs; });
+	
+	py::class_<SpecCase>(m, "SpecCase")
+		.def_property_readonly("input_box", [](const SpecCase& c){ return c.inputBox; })
+		.def_property_readonly("output_constraints", [](const SpecCase& c){ return c.outputConstraints; },
+								py::return_value_policy::reference_internal);
+
+	// --- API ---
+	m.def("parse_query_file", [](const std::string& path) {
+		return parseQueryFile(path);
+	},
+	py::return_value_policy::move,
+	py::arg("path"));
+	
+	m.def("parse_query_string", [](const std::string& content) {
+		return parseQueryString(content);
+	},
+	py::return_value_policy::move,
+	py::arg("content"));
+
+	m.def("transform_to_compat", [](const TQuery& query) {
+		CompatTransformer transformer(&query);
+		const auto& cases = transformer.transform();
+
+		py::list py_cases;
+		for (const auto& c : cases) {
+			py_cases.append(py::cast(c, py::return_value_policy::move));
+		}
+		return py_cases;
+	},
+	py::arg("query"));
+
+	m.attr("__version__") = "0.2.0";
+}
+

vnnlib/_core.pyi

@@ -0,0 +1,270 @@
+"""Type stubs for VNNLib (typed AST)"""
+
+from __future__ import annotations
+from typing import List, Tuple, Optional, Any
+from enum import Enum
+
+# --- Exceptions --------------------------------------------------------------
+
+class VNNLibException(Exception): ...
+
+
+# --- Enums / Aliases --------------------------------------------------------
+
+class DType(Enum):
+    F16: DType
+    F32: DType
+    F64: DType
+    BF16: DType
+    F8E4M3FN: DType
+    F8E5M2: DType
+    F8E4M3FNUZ: DType
+    F8E5M2FNUZ: DType
+    F4E2M1: DType
+    I8: DType
+    I16: DType
+    I32: DType
+    I64: DType
+    U8: DType
+    U16: DType
+    U32: DType
+    U64: DType
+    C64: DType
+    C128: DType
+    Bool: DType
+    String: DType
+    Unknown: DType
+    NegativeIntConstant: DType
+    PositiveIntConstant: DType
+    FloatConstant: DType
+
+class SymbolKind(Enum):
+    Input: SymbolKind
+    Hidden: SymbolKind
+    Output: SymbolKind
+    Unknown: SymbolKind
+
+Shape = List[int]
+
+
+# --- Base node ---------------------------------------------------------------
+
+class Node:
+    def __str__(self) -> str: ...
+    def children(self) -> Tuple[Node, ...]: ...
+
+
+# --- Arithmetic --------------------------------------------------------------
+
+class ArithExpr(Node):
+    @property
+    def dtype(self) -> DType: ...
+    def to_linear_expr(self) -> LinearArithExpr: ...
+
+class Var(ArithExpr):
+    @property
+    def name(self) -> str: ...
+    @property
+    def indices(self) -> List[int]: ...
+    @property
+    def dtype(self) -> DType: ...
+    @property
+    def shape(self) -> Shape: ...
+    @property
+    def kind(self) -> SymbolKind: ...
+    @property
+    def onnx_name(self) -> Optional[str]: ...
+    @property
+    def network_name(self) -> str: ...
+    @property
+    def line(self) -> int: ...
+
+class Literal(ArithExpr):
+    @property
+    def lexeme(self) -> str: ...
+    @property
+    def line(self) -> int: ...
+
+class Float(ArithExpr):
+    @property
+    def value(self) -> float: ...
+
+class Int(ArithExpr):
+    @property
+    def value(self) -> int: ...
+
+class IntExpr(ArithExpr):
+    @property
+    def value(self) -> int: ...
+    @property
+    def lexeme(self) -> str: ...
+
+class Negate(ArithExpr):
+    @property
+    def expr(self) -> ArithExpr: ...
+
+class Plus(ArithExpr):
+    @property
+    def args(self) -> Tuple[ArithExpr, ...]: ...
+
+class Minus(ArithExpr):
+    @property
+    def head(self) -> ArithExpr: ...
+    @property
+    def rest(self) -> Tuple[ArithExpr, ...]: ...
+
+class Multiply(ArithExpr):
+    @property
+    def args(self) -> Tuple[ArithExpr, ...]: ...
+
+
+# --- Linear Arithmetic -------------------------------------------------------
+
+class Term:
+    @property
+    def coeff(self) -> float: ...
+    @property
+    def var_name(self) -> str: ...
+    @property
+    def var(self) -> Var: ...
+
+class LinearArithExpr:
+    @property
+    def terms(self) -> List[Term]: ...
+    @property
+    def constant(self) -> float: ...
+
+
+# --- Boolean -----------------------------------------------------------------
+
+class BoolExpr(Node):
+    def to_dnf(self) -> List[List[Comparison]]: ...
+
+class Comparison(BoolExpr):
+    @property
+    def lhs(self) -> ArithExpr: ...
+    @property
+    def rhs(self) -> ArithExpr: ...
+
+class GreaterThan(Comparison): ...
+class LessThan(Comparison): ...
+class GreaterEqual(Comparison): ...
+class LessEqual(Comparison): ...
+class Equal(Comparison): ...
+class NotEqual(Comparison): ...
+
+class Connective(BoolExpr):
+    @property
+    def args(self) -> Tuple[BoolExpr, ...]: ...
+
+class And(Connective): ...
+class Or(Connective): ...
+
+
+# --- Assertions --------------------------------------------------------------
+
+class Assertion(Node):
+    @property
+    def expr(self) -> BoolExpr: ...
+
+
+# --- Declarations ------------------------------------------------------------
+
+class InputDefinition(Node):
+    @property
+    def name(self) -> str: ...
+    @property
+    def dtype(self) -> DType: ...
+    @property
+    def shape(self) -> Shape: ...
+    @property
+    def kind(self) -> SymbolKind: ...
+    @property
+    def onnx_name(self) -> Optional[str]: ...
+    @property
+    def network_name(self) -> str: ...
+
+class HiddenDefinition(Node):
+    @property
+    def name(self) -> str: ...
+    @property
+    def dtype(self) -> DType: ...
+    @property
+    def shape(self) -> Shape: ...
+    @property
+    def kind(self) -> SymbolKind: ...
+    @property
+    def onnx_name(self) -> Optional[str]: ...
+    @property
+    def network_name(self) -> str: ...
+
+class OutputDefinition(Node):
+    @property
+    def name(self) -> str: ...
+    @property
+    def dtype(self) -> DType: ...
+    @property
+    def shape(self) -> Shape: ...
+    @property
+    def kind(self) -> SymbolKind: ...
+    @property
+    def onnx_name(self) -> Optional[str]: ...
+    @property
+    def network_name(self) -> str: ...
+
+
+# --- Network ---------------------------------------------------------
+
+class Network(Node):
+    @property
+    def name(self) -> str: ...
+    @property
+    def equal_to(self) -> str: ...
+    @property
+    def isometric_to(self) -> str: ...
+    @property
+    def inputs(self) -> Tuple[InputDefinition, ...]: ...
+    @property
+    def hidden(self) -> Tuple[HiddenDefinition, ...]: ...
+    @property
+    def outputs(self) -> Tuple[OutputDefinition, ...]: ...
+
+
+# --- Version -----------------------------------------------------------
+
+class Version(Node):
+    @property
+    def major(self) -> int: ...
+    @property
+    def minor(self) -> int: ...
+
+
+class Query(Node):
+    @property
+    def networks(self) -> Tuple[Network, ...]: ...
+    @property
+    def assertions(self) -> Tuple[Assertion, ...]: ...
+
+
+# --- Compatibility (Reachability Format) ------------------------------------
+
+class Polytope:
+    @property
+    def coeff_matrix(self) -> List[List[float]]: ...
+    @property
+    def rhs(self) -> List[float]: ...
+
+class SpecCase:
+    @property
+    def input_box(self) -> List[Tuple[float, float]]: ...
+    @property  
+    def output_constraints(self) -> List[Polytope]: ...
+
+
+# --- Parse API (typed) -------------------------------------------------------
+
+def parse_query_file(path: str) -> Query: ...
+def parse_query_string(content: str) -> Query: ...
+def transform_to_compat(query: Query) -> List[SpecCase]: ...
+
+__version__: str

vnnlib/compat/__init__.py

@@ -0,0 +1,54 @@
+"""
+VNNLib Compatibility Module
+
+This module provides classes and functions for converting VNNLib specifications
+to reachability format compatible with reachability analysis tools.
+
+The reachability format represents verification problems as:
+1. Input constraints as box bounds (lower/upper bounds per input dimension)  
+2. Output constraints as polytopes in the form Ay ≤ b
+"""
+
+from .._core import Polytope, SpecCase, transform_to_compat
+
+__all__ = [
+    "Polytope",
+    "SpecCase", 
+    "transform",
+]
+
+def transform(query):
+    """
+    Transform a VNNLib Query to reachability format.
+    
+    This function converts VNNLib specifications into a list of reachability cases.
+    Each case consists of:
+    1. Input box bounds: lower and upper bounds for each input dimension
+    2. Output polytopes: constraints in the form Ay ≤ b representing disjunctions
+    
+    Parameters
+    ----------
+    query : vnnlib.Query
+        The parsed VNNLib Query object to transform
+        
+    Returns
+    -------
+    List[SpecCase]
+        A list of reachability cases with input bounds and output constraints
+        
+    Raises
+    ------
+    VNNLibException
+        If the specification cannot be converted to reachability format.
+        
+    Example
+    -------
+    >>> import vnnlib
+    >>> import vnnlib.compat
+    >>> query = vnnlib.parse_query_string(content)
+    >>> cases = vnnlib.compat.transform(query)
+    >>> case = cases[0]
+    >>> print(f"Input bounds: {case.input_box}")
+    >>> print(f"Output polytopes: {len(case.output_constraints)}")
+    """
+    return transform_to_compat(query)

vnnlib/py.typed

@@ -0,0 +1 @@
+"""Stub-only package"""

vnnlib-1.0.0.dist-info/METADATA

@@ -0,0 +1,48 @@
+Metadata-Version: 2.2
+Name: vnnlib
+Version: 1.0.0
+Summary: Python bindings for VNNLib parsing and AST manipulation
+Author-Email: Allen Antony <allenantony2001@gmail.com>
+License: MIT
+Requires-Python: >=3.7
+Requires-Dist: pybind11>=2.6.0
+Description-Content-Type: text/markdown
+
+# VNN-LIB Python
+
+A Python package for parsing and manipulating neural network properties in the updated [VNN-LIB format](https://www.vnnlib.org/). 
+
+## Features
+
+Features include:
+- Parsing: Convert VNN-LIB file or string into a type-checked AST
+- AST traversal: Access, traverse, and convert the AST back to a string.
+- Transformers:
+    - Linearise arithmetic expressions
+    - Convert boolean expressions to Disjunctive Normal Form (DNF)
+    - Transform spec to reachability format used in prior VNN-COMPs.
+
+## Installation
+
+Install the latest stable version via PyPi:
+```bash
+pip install vnnlib
+```
+
+## Basic Usage
+
+```python
+import vnnlib
+
+# Parse a VNN-LIB specification
+query = vnnlib.parse_query_file("path/to/spec.vnnlib")
+
+for assertion in query.assertions:
+    print(assertion)
+```
+
+## Version compatibility
+
+| VNNLIB-Python version | VNNLIB version |
+| --- | --- |
+| v1.0 | v2.0 |

vnnlib-1.0.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+vnnlib-1.0.0.dist-info/RECORD,,
+vnnlib-1.0.0.dist-info/WHEEL,sha256=_zINgRxDmPoJWl94R6FZTGt8Bzncj3Uu9X9upp27784,143
+vnnlib-1.0.0.dist-info/METADATA,sha256=wnjLAqg4wr6n4vhRvMk3n7JSaorccIUrswfn5L16WMI,1171
+vnnlib-1.0.0.dist-info/licenses/LICENSE,sha256=aRYsrTcINTRh5FTXvbHARWhog18NPO_tjECDhbAOzR0,1086
+vnnlib/libVNNLib.dylib,sha256=iFgVLr4nzrOE2Sg8kfzx3UTXZH_iJYF8WLv_9YIge3g,367264
+vnnlib/__init__.pyi,sha256=YChDCtUFDV14VsSrt5Bz8stAebymJI0wZDULC-qUopU,66
+vnnlib/_core.pyi,sha256=3FZcIOvRfm9LN7VwttvNUrRH5wky1Ug0oeAX-8KUGRg,6219
+vnnlib/_core.cpp,sha256=ILh96cmpasRhqMZFkz60Z9w7lOMAekoFGUv0WR-QOvk,13238
+vnnlib/__init__.py,sha256=-TtOOw7D9hk8tXZyyMStBJwnkdxN0eulf3OVPHlk1PI,1990
+vnnlib/py.typed,sha256=wedgqpT4WwmZzs6C28NAC9NiqQc0Yvpd-7QizLn4QFo,24
+vnnlib/_core.cpython-311-darwin.so,sha256=KtEF15dsvbQ1J45HFZAO2zKQHg086h3DcnqxH48kNX0,346448
+vnnlib/compat/__init__.py,sha256=FY8SajqtUAVDliUfrFV19QEd5IOomeSjE3T3DLd_qL8,1597
+vnnlib/compat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

vnnlib-1.0.0.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: scikit-build-core 0.11.6
+Root-Is-Purelib: false
+Tag: cp311-cp311-macosx_10_15_x86_64
+Generator: delocate 0.13.0
+

vnnlib-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Allen Anthony, Matthew Daggitt
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.