vnnlib 0.0.1a0__py3-none-any.whl → 0.0.1a2__py3-none-any.whl

vnnlib/__init__.py

@@ -0,0 +1,3 @@
+from .parser import VnnLibParser, parse_file
+
+__all__ = ["VnnLibParser", "parse_file"]

vnnlib/__main__.py

@@ -1,18 +1,52 @@
+from __future__ import annotations
+
 import argparse
+import pickle
+from pathlib import Path
+
+from .compat import CompatTransformer
+from .parser import parse_file
 
 
-def parse_args():
+def parse_args() -> argparse.Namespace:
     parser = argparse.ArgumentParser(
         "vnnlib",
         description="",
     )
-    parser.add_argument("file", nargs="+")
+    parser.add_argument("file", type=Path)
+    parser.add_argument(
+        "--compat", action="store_true", help="Use the VNN-COMP-1 output format"
+    )
+    parser.add_argument(
+        "--strict",
+        action=argparse.BooleanOptionalAction,
+        default=True,
+        help="Whether or not to strictly follow VNN-LIB (default: True)",
+    )
+    parser.add_argument(
+        "-o", "--output", type=str, help="The path to save the compiled output"
+    )
     return parser.parse_args()
 
 
-def __main__():
+def __main__() -> None:
     args = parse_args()
-    print(f"parsing {args.file}")
+    file: Path = args.file
+    print(f"parsing file: {args.file}")
+
+    if args.compat:
+        if ".vnnlib" in file.suffixes:
+            ast_node = parse_file(file, strict=args.strict)
+            result = CompatTransformer("X", "Y").transform(ast_node)
+            if args.output:
+                with open(args.output, "wb+") as f:
+                    pickle.dump(result, f)
+        else:
+            raise RuntimeError(f"Unsupported file type: {file.suffix}")
+    else:
+        raise NotImplementedError(
+            "Currently only the VNN-COMP-1 output format is supported"
+        )
 
 
 if __name__ == "__main__":

vnnlib/__version__.py

@@ -1 +1 @@
-__version__ = "0.0.1a0"
+__version__ = "0.0.1a2"

vnnlib/compat.py

@@ -0,0 +1,238 @@
+from __future__ import annotations
+
+import operator
+import pathlib
+from typing import Dict, List, Optional, Tuple, Union
+
+import numpy as np
+
+from .parser import AstNodeTransformer, Real, parse_file
+
+
+class CompatTransformer(AstNodeTransformer):
+    def __init__(
+        self,
+        input_name: str,
+        output_name: str,
+        input_size: Optional[int] = None,
+        output_size: Optional[int] = None,
+    ) -> None:
+        self.input_name = input_name
+        self.output_name = output_name
+
+        self.input_size = input_size or 0
+        self.output_size = output_size or 0
+
+        self.infer_input_size = input_size is None
+        self.infer_output_size = output_size is None
+
+        self._id_map: Dict[str, int] = {}
+        self._assertions: Dict[Tuple[int, ...], Real] = {}
+        self._num_assertions = 0
+        self._disjunctions: List[Dict[Tuple[int, ...], Real]] = [{}]
+
+    def transform_Assert(
+        self,
+        term: Union[List[Dict[Tuple[int, ...], Real]], Dict[Tuple[int, ...], Real]],
+    ) -> List[Dict[Tuple[int, ...], Real]]:
+        if isinstance(term, list):
+            if len(term) == 1:
+                row_offset = self._num_assertions
+                max_row = 0
+                for (row, *index), value in term[0].items():
+                    self._assertions[(row + row_offset, *index)] = value
+                    max_row = max(max_row, row)
+                if len(term[0]):
+                    self._num_assertions += max_row + 1
+            elif len(self._disjunctions) == 1:
+                new_disjunctions = []
+                for disjunct in term:
+                    disjunct = disjunct.copy()
+                    new_disjunctions.append(disjunct)
+                    row_offset = max(disjunct, default=(-1,))[0] + 1
+                    for (row, *index), value in self._disjunctions[0].items():
+                        disjunct[(row + row_offset, *index)] = value
+                self._disjunctions = new_disjunctions
+            else:
+                assert False
+            return term
+        if isinstance(term, dict):
+            row_offset = self._num_assertions
+            max_row = 0
+            for (row, *index), value in term.items():
+                self._assertions[(row + row_offset, *index)] = value
+                max_row = max(max_row, row)
+            if len(term):
+                self._num_assertions += max_row + 1
+            return [term]
+        raise RuntimeError("unexpected term for assert")
+
+    def transform_Constant(self, value) -> Dict[Tuple[int, ...], Real]:
+        assert isinstance(value, (Real, int))
+        return {(0, -1, -1): value}
+
+    def transform_DeclareConst(self, symbol: str, sort: str) -> None:
+        if self.infer_input_size and symbol.startswith(f"{self.input_name}_"):
+            _, index = symbol.split("_")
+            self.input_size = max(self.input_size, int(index) + 1)
+        elif self.infer_output_size and symbol.startswith(f"{self.output_name}_"):
+            _, index = symbol.split("_")
+            self.output_size = max(self.output_size, int(index) + 1)
+
+    def transform_FunctionApplication(
+        self,
+        symbol: str,
+        *terms: Union[List[Dict[Tuple[int, ...], Real]], Dict[Tuple[int, ...], Real]],
+    ) -> Union[List[Dict[Tuple[int, ...], Real]], Dict[Tuple[int, ...], Real]]:
+        if symbol == "<=":
+            lhs, rhs = terms
+            assert isinstance(lhs, dict)
+            assert isinstance(rhs, dict)
+            result = lhs.copy()
+            for key, value in rhs.items():
+                result[key] = result.get(key, 0) - value
+            return result
+        elif symbol == ">=":
+            lhs, rhs = terms
+            assert isinstance(lhs, dict)
+            assert isinstance(rhs, dict)
+            result = rhs.copy()
+            for key, value in lhs.items():
+                result[key] = result.get(key, 0) - value
+            return result
+        elif symbol == "and":
+            conjuncts = {}
+            for i, term in enumerate(terms):
+                assert isinstance(term, dict)
+                for (row, *index), value in term.items():
+                    assert row == 0
+                    assert len(index) == 2, "please open a bug report"
+                    conjuncts[(i, *index)] = value
+            return [conjuncts]
+        elif symbol == "or":
+            or_result = []
+            for term in terms:
+                assert isinstance(term, list), "please open a bug report"
+                for subterm in term:
+                    assert isinstance(subterm, dict), "please open a bug report"
+                or_result.extend(term)
+            return or_result
+        else:
+            raise NotImplementedError(
+                f"Function {symbol!r} is not supported by the legacy parser"
+            )
+
+    def transform_Identifier(
+        self, value: str
+    ) -> Union[str, Dict[Tuple[int, ...], Real]]:
+        if value.startswith(f"{self.input_name}_"):
+            _, *str_index = value.split("_")
+            return {(0, 0, *tuple(map(int, str_index))): 1}
+        elif value.startswith(f"{self.output_name}_"):
+            _, *str_index = value.split("_")
+            return {(0, 1, *tuple(map(int, str_index))): 1}
+        elif value in {"<=", ">=", "and", "or"}:
+            return value
+        if value not in self._id_map:
+            self._id_map[value] = len(self._id_map) + 2
+        return {(0, self._id_map[value]): 1}
+
+    def transform_Script(self, *commands):
+        common_box = [[float("-inf"), float("inf")] for _ in range(self.input_size)]
+        common_polytope = []
+        input_box_rows = set()
+        output_polytope_rows = set()
+        rhs = 0
+        for (row, var_type, index), value in sorted(
+            self._assertions.items(), key=operator.itemgetter(0)
+        ):
+            assert var_type <= 0 or row not in input_box_rows
+            if var_type == -1:
+                rhs = value
+                continue
+            if var_type == 0:
+                input_box_rows.add(row)
+                if value == 1:
+                    common_box[index][1] = min(-rhs, common_box[index][1])
+                elif value == -1:
+                    common_box[index][0] = max(rhs, common_box[index][0])
+                else:
+                    raise RuntimeError(f"unexpected lhs coeff for box: {value}")
+                rhs = 0
+                continue
+            if var_type == 1:
+                output_polytope_rows.add(row)
+                polytope_row = row - min(output_polytope_rows)
+                if len(common_polytope) <= polytope_row:
+                    common_polytope.append(
+                        [[0 for _ in range(self.output_size)], [rhs]]
+                    )
+                    rhs = 0
+                common_polytope[polytope_row][0][index] = value
+                continue
+            raise RuntimeError(f"unexpected variable type {var_type}")
+        results = {}
+        for disjunct in self._disjunctions:
+            box = [interval.copy() for interval in common_box]
+            polytope = [[lhs.copy(), rhs.copy()] for lhs, rhs in common_polytope]
+            input_box_rows = set()
+            output_polytope_rows = set()
+            rhs = 0
+            for (row, var_type, index), value in sorted(
+                disjunct.items(), key=lambda kv: kv[0]
+            ):
+                assert var_type <= 0 or row not in input_box_rows
+                if var_type == -1:
+                    rhs = value
+                    continue
+                if var_type == 0:
+                    input_box_rows.add(row)
+                    if value == 1:
+                        box[index][1] = min(-rhs, box[index][1])
+                    elif value == -1:
+                        box[index][0] = max(rhs, box[index][0])
+                    else:
+                        raise RuntimeError(f"unexpected lhs coeff for box: {value}")
+                    rhs = 0
+                    continue
+                if var_type == 1:
+                    output_polytope_rows.add(row)
+                    polytope_row = (
+                        row - min(output_polytope_rows) + len(common_polytope)
+                    )
+                    if len(polytope) <= polytope_row:
+                        polytope.append([[0 for _ in range(self.output_size)], [rhs]])
+                        rhs = 0
+                    polytope[polytope_row][0][index] = value
+                    continue
+                raise RuntimeError(f"unexpected variable type {var_type}")
+            box_str = str(box)
+            polytope_arr = (
+                np.array([lhs for lhs, _ in polytope]),
+                np.array([rhs for _, rhs in polytope]),
+            )
+            if box_str not in results:
+                results[box_str] = [box, [polytope_arr]]
+            else:
+                results[box_str][1].append(polytope_arr)
+        return list(results.values())
+
+
+def read_vnnlib_simple(
+    vnnlib_filename: Union[str, pathlib.Path], num_inputs: int, num_outputs: int
+) -> List[Tuple[List[Real], Tuple[np.ndarray, np.ndarray]]]:
+    """process in a vnnlib file. You can get num_inputs and num_outputs using get_num_inputs_outputs().
+
+    output a list containing 2-tuples:
+        1. input ranges (box), list of pairs for each input variable
+        2. specification, provided as a list of pairs (mat, rhs), as in: mat * y <= rhs, where y is the output.
+                          Each element in the list is a term in a disjunction for the specification.
+    """
+    ast_node = parse_file(vnnlib_filename, strict=False)
+    result = CompatTransformer("X", "Y", num_inputs, num_outputs).transform(ast_node)
+    return result
+
+
+__all__ = [
+    "read_vnnlib_simple",
+]

vnnlib/errors.py

@@ -0,0 +1,11 @@
+class ParserError(Exception):
+    def __init__(self, msg: str, *args: object, lineno=None, col_offset=None) -> None:
+        if lineno is not None:
+            prefix = f"line {lineno}"
+            if col_offset is not None:
+                prefix = f"{prefix}, column {col_offset}"
+            msg = f"{prefix}: {msg}"
+        super().__init__(msg, *args)
+
+
+__all__ = ["ParserError"]

vnnlib/parser.py

@@ -0,0 +1,368 @@
+from __future__ import annotations
+
+import bz2
+import gzip
+import lzma
+import re
+import warnings
+from pathlib import Path
+from typing import (
+    Callable,
+    Dict,
+    Iterator,
+    List,
+    NamedTuple,
+    Optional,
+    Set,
+    TextIO,
+    Union,
+)
+
+from .errors import ParserError
+
+Real = float
+
+
+class Meta(NamedTuple):
+    start_pos: int
+    end_pos: int
+
+
+class Token(NamedTuple):
+    token_type: str
+    value: str
+    meta: Meta
+
+
+def as_dict(t: NamedTuple):
+    return t._asdict()
+
+
+_DUMMY_TOKEN = Token("_", "", Meta(0, 0))
+EOF = Token("EOF", "", Meta(-1, -1))
+
+
+def tokenize(text: str, skip: Set[str], strict=True) -> Iterator[Token]:
+    if len(text) == 0:
+        return
+    tokens: Dict[str, str] = {
+        "COMMENT": r";[\t -~]*(?:[\r\n]|$)",
+        "WS": r"\x09|\x0a|\x0d|\x20",
+        "LPAREN": r"\(",
+        "RPAREN": r"\)",
+        "BINARY": r"#b[01]+",
+        "HEXADECIMAL": r"#x[0-9A-Fa-f]+",
+        "_DECIMAL_strict": r"(?:{NUMERAL})\.0*(?:{NUMERAL})",
+        "_DECIMAL_extended": r"(?:(?:{NUMERAL})\.0*(?:{NUMERAL})(?:[eE][+-]?0*(?:{NUMERAL}))?)",
+        "DECIMAL": f"(?:{{_DECIMAL_{'strict' if strict else 'extended'}}})",
+        "NUMERAL": r"(?:(?:[1-9][0-9]*)|0)",
+        "STRING": r"\x22(?:(?:{WS})|(?:{_PRINTABLE_CHAR}))*\x22",
+        "SYMBOL": r"(?:(?:(?:{_LETTER})|(?:{_CHARACTER}))(?:[0-9]|(?:{_LETTER})|(?:{_CHARACTER}))*)|(?:\x7c(?:[\x20-\x5b]|[\x5d-\x7b]|[\x7d\x7e]|[\x80-\xff])*\x7c)",
+        "_PRINTABLE_CHAR": r"[\x20-\x7e]|[\x80-\xff]",
+        "_LETTER": r"[A-Za-z]",
+        "_CHARACTER": r"[~!@$%^&*+=<>.?/_-]",
+    }
+    for key, value in tokens.items():
+        tokens[key] = value.format(**tokens)
+    token_pattern = re.compile(
+        "|".join(
+            f"(?P<{token_type}>{pattern})"
+            for token_type, pattern in tokens.items()
+            if not token_type.startswith("_")
+        )
+    )
+    pos: int = 0
+    for match in token_pattern.finditer(text):
+        start_pos, end_pos = match.span()
+        if start_pos != pos:
+            raise ParserError(f"Unknown string: {text[pos:start_pos]!r}")
+        assert match.lastgroup is not None
+        if match.lastgroup not in skip:
+            yield Token(match.lastgroup, match.group(), Meta(start_pos, end_pos))
+        pos = end_pos
+    if pos != len(text):
+        raise ParserError(f"Unknown string: {text[pos:]!r}")
+
+
+class AstNode:
+    @property
+    def _type(self) -> str:
+        return self.__class__.__name__
+
+
+class Script(AstNode):
+    def __init__(self, *commands: Command):
+        self.commands = commands
+
+
+class Command(AstNode):
+    pass
+
+
+class Declare(Command):
+    pass
+
+
+class DeclareConst(Declare):
+    def __init__(self, symbol: str, sort: str):
+        self.symbol = symbol
+        self.sort = sort
+
+
+class Assert(Command):
+    def __init__(self, term: Term):
+        self.term = term
+
+
+class Term(AstNode):
+    pass
+
+
+class FunctionApplication(Term):
+    def __init__(self, function: Identifier, *terms: Term):
+        self.function = function
+        self.terms = terms
+
+
+class Constant(Term):
+    def __init__(self, value: float | int | str | Real):
+        self.value = value
+
+
+class Sort(AstNode):
+    def __init__(self, value: str):
+        self.value = value
+
+
+class Identifier(Term):
+    def __init__(self, value: str, sort: Sort):
+        self.value = value
+
+
+def _hex_to_int(x: str) -> int:
+    return int(x[2:], 16)
+
+
+def _bin_to_int(x: str) -> int:
+    return int(x[2:], 2)
+
+
+def _identity(x: str) -> str:
+    return x
+
+
+LITERAL_CONVERTERS: Dict[str, Callable[[str], float | int | str | Real]] = {
+    "DECIMAL": Real,
+    "NUMERAL": int,
+    "HEXADECIMAL": _hex_to_int,
+    "BINARY": _bin_to_int,
+    "STRING": _identity,
+}
+CORE_IDS: Dict[str, Identifier] = {
+    # arithmetic
+    "+": Identifier("+", Sort("(A A) A")),
+    "-": Identifier("-", Sort("(A A) A")),
+    "*": Identifier("*", Sort("(A A) A")),
+    "/": Identifier("/", Sort("(A A) A")),
+    # comparisons
+    ">": Identifier(">", Sort("(A A) Bool")),
+    ">=": Identifier(">=", Sort("(A A) Bool")),
+    "<": Identifier("<", Sort("(A A) Bool")),
+    "<=": Identifier("<=", Sort("(A A) Bool")),
+    "=": Identifier("=", Sort("(A A) Bool")),
+    # logic
+    "true": Identifier("true", Sort("Bool")),
+    "false": Identifier("false", Sort("Bool")),
+    "not": Identifier("not", Sort("(Bool Bool)")),
+    "=>": Identifier("=>", Sort("(Bool Bool) Bool")),
+    "or": Identifier("or", Sort("(Bool Bool) Bool")),
+    "and": Identifier("and", Sort("(Bool Bool) Bool")),
+    "xor": Identifier("xor", Sort("(Bool Bool) Bool")),
+    "ite": Identifier("ite", Sort("(Bool A A) A")),
+}
+
+
+class VnnLibParser:
+    def __init__(self, token_stream: Iterator[Token]):
+        self.token_stream = token_stream
+        self.curr_token = _DUMMY_TOKEN
+        self.sorts = {"Bool": Sort("Bool"), "Int": Sort("Int"), "Real": Sort("Real")}
+        self.identifiers: Dict[str, Identifier] = CORE_IDS.copy()
+
+    def advance_token_stream(self) -> Token:
+        self.curr_token = next_token = next(self.token_stream, EOF)
+        return next_token
+
+    def expect_token_type(
+        self,
+        type: str,
+        *,
+        expected_value: Optional[str] = None,
+        msg: str = "unexpected token: {token_type}({value!r})",
+    ) -> bool:
+        if self.curr_token.token_type == type:
+            return True
+        if expected_value:
+            raise ParserError(f"Expected {expected_value!r}")
+        raise ParserError(msg.format(**as_dict(self.curr_token)))
+
+    def lookup_identifier(self, identifier: str) -> Identifier:
+        if identifier not in self.identifiers:
+            if (
+                identifier.startswith("e")
+                and len(identifier) >= 2
+                and not set(identifier[1:]).difference(set("0123456789+-"))
+            ):
+                raise ParserError(
+                    (
+                        f"undeclared identifier: {identifier!r}."
+                        "\n\tIt looks like this may be exponential notation, which is not SMT-LIB compliant."
+                        "\n\tTry turning of strict mode."
+                    )
+                )
+            raise ParserError(f"undeclared identifier: {identifier!r}")
+        return self.identifiers[identifier]
+
+    def lookup_sort(self, name: str) -> Sort:
+        if name not in self.sorts:
+            raise ParserError(f"undeclared sort: {name!r}")
+        return self.sorts[name]
+
+    @classmethod
+    def parse(cls, text: str, strict=True) -> Script:
+        parser = VnnLibParser(tokenize(text, {"WS", "COMMENT"}, strict=strict))
+        parser.advance_token_stream()
+        commands = []
+        while parser.curr_token != EOF:
+            commands.append(parser.parse_command())
+        return Script(*commands)
+
+    def parse_command(self) -> Command:
+        self.expect_token_type(type="LPAREN", expected_value="(")
+        curr_token = self.advance_token_stream()
+        command = curr_token.value
+        command_parsers = {
+            "assert": self.parse_assert,
+            "declare-const": self.parse_declare_const,
+        }
+        if command not in command_parsers:
+            raise ParserError(f"Unknown command: {command!r}")
+        node = command_parsers[command]()
+        self.expect_token_type(type="RPAREN", expected_value=")")
+        self.advance_token_stream()
+        return node
+
+    def parse_declare_const(self) -> Declare:
+        symbol = self.advance_token_stream()
+        self.expect_token_type("SYMBOL")
+        sort = self.advance_token_stream()
+        self.expect_token_type("SYMBOL")
+        self.advance_token_stream()
+        self.identifiers[symbol.value] = Identifier(
+            symbol.value, self.lookup_sort(sort.value)
+        )
+        return DeclareConst(symbol.value, sort.value)
+
+    def parse_assert(self) -> Assert:
+        self.advance_token_stream()
+        return Assert(self.parse_term())
+
+    def parse_term(self) -> Term:
+        curr_token = self.curr_token
+        token_type = curr_token.token_type
+        if token_type == "SYMBOL":
+            self.advance_token_stream()
+            if curr_token.value.startswith("-"):
+                warnings.warn("literal negation does not strictly follow SMT-LIB")
+                try:
+                    float_value = Real(curr_token.value)
+                    return Constant(float_value)
+                except:
+                    pass
+                return FunctionApplication(
+                    self.lookup_identifier("-"),
+                    self.lookup_identifier(curr_token.value[1:]),
+                )
+            return self.lookup_identifier(curr_token.value)
+        if token_type == "LPAREN":
+            children: List[Term] = []
+            function_id_token = self.advance_token_stream()
+            self.expect_token_type("SYMBOL")
+            self.advance_token_stream()
+            children.append(self.parse_term())
+            while self.curr_token.token_type != "RPAREN":
+                children.append(self.parse_term())
+            self.advance_token_stream()
+            return FunctionApplication(
+                self.lookup_identifier(function_id_token.value), *children
+            )
+        if token_type in LITERAL_CONVERTERS:
+            value = LITERAL_CONVERTERS[token_type](curr_token.value)
+            self.advance_token_stream()
+            return Constant(value)
+        raise ParserError(f"Unexpected token: {curr_token}")
+
+
+def _identity_args(*args):
+    return args
+
+
+class _Discard:
+    pass
+
+
+Discard = _Discard()
+
+
+class AstNodeTransformer:
+    def transform(self, node: AstNode):
+        args = getattr(self, f"_visit_{node._type}")(node)
+        return getattr(self, f"transform_{node._type}", _identity_args)(*args)
+
+    def _visit_Assert(self, node: Assert):
+        result = self.transform(node.term)
+        return (result,)
+
+    def _visit_Constant(self, node: Constant):
+        return (node.value,)
+
+    def _visit_DeclareConst(self, node: DeclareConst):
+        return (node.symbol, node.sort)
+
+    def _visit_FunctionApplication(self, node: FunctionApplication):
+        function = self.transform(node.function)
+        terms = [self.transform(term) for term in node.terms]
+        return (function, *terms)
+
+    def _visit_Identifier(self, node: Identifier):
+        return (node.value,)
+
+    def _visit_Script(self, node: Script):
+        results = []
+        for command in node.commands:
+            result = self.transform(command)
+            if result is not Discard:
+                results.append(result)
+        return results
+
+
+def parse_file(filename: Union[str, Path], strict=True) -> AstNode:
+    if isinstance(filename, str):
+        filename = Path(filename)
+    open_func: Callable[[Union[str, Path]], TextIO]
+    if filename.suffix in {".gz", ".gzip"}:
+        open_func = lambda fname: gzip.open(fname, "rt")
+    elif filename.suffix in {".bz2", ".bzip2"}:
+        open_func = lambda fname: bz2.open(fname, "rt")
+    elif filename.suffix == ".xz":
+        open_func = lambda fname: lzma.open(fname, "rt")
+    else:
+        open_func = open
+
+    with open_func(filename) as f:
+        text = f.read()
+    ast_node = VnnLibParser.parse(text, strict=strict)
+    return ast_node
+
+
+__all__ = ["VnnLibParser", "parse_file"]

{vnnlib-0.0.1a0.dist-info → vnnlib-0.0.1a2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: vnnlib
-Version: 0.0.1a0
+Version: 0.0.1a2
 Author-email: David Shriver <davidshriver@outlook.com>
 License: MIT
 Project-URL: Documentation, https://github.com/dlshriver/vnnlib#readme
@@ -47,17 +47,49 @@ Requires-Dist: pytest (~=7.2.1) ; extra == 'test'
 
 -----
 
-**Table of Contents**
+A python package for parsing neural network properties in the [VNN-LIB format](https://www.vnnlib.org/).
+It should currently parse a superset of the VNN-LIB spec supported by [example parser](https://github.com/stanleybak/nnenum/blob/master/src/nnenum/vnnlib.py) written by Stan Bak for [VNN-COMP](https://sites.google.com/view/vnn2023), and will produce compiled specs in the same format.
+Additionally, we allow parsing of gzip, bzip2, and lzma compressed specs.
+
+> Our parser is currently slower than the previous scripts due to the increased specification support. However, we expect significant optimization opportunities are available, and that overhead will decrease over time.
+
+> This package is still alpha software and APIs other than the compatibility API may change before the first release. We hope to have a stable release out before or during the benchmark proposal phase of VNN-COMP 2023.
 
-- [Installation](#installation)
-- [License](#license)
 
 ## Installation
 
+For the latest stable version, you can install from PyPI with:
+
 ```console
 pip install vnnlib
 ```
 
+> PyPI currently only has pre-releases of `vnnlib`. To install a pre-release version, add the `--pre` option to the above command.
+
+For the latest updates of `vnnlib`, you can pip install directly from the GitHub repo with:
+
+```console
+pip install git+https://github.com/dlshriver/vnnlib.git@main
+```
+
+## Usage
+
+This package can be used as a drop-in replacement for the VNN-COMP utility script by importing 
+
+```python
+from vnnlib.compat import read_vnnlib_simple
+```
+
+wherever you previously imported `read_vnnlib_simple`.
+
+### Standalone
+
+The parser can also be used to compile vnnlib ahead of time to reduce future property read times. The result of parsing will be pickled and saved to the location specified.
+
+```console
+python -m vnnlib [FILE] --compat -o [OUTPUTFILE]
+```
+
 ## License
 
 `vnnlib` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

vnnlib-0.0.1a2.dist-info/RECORD

@@ -0,0 +1,11 @@
+vnnlib/__init__.py,sha256=omfedQ-RoZiKP9S45H_m-HymipFJN__PxlX-_gzQr7A,87
+vnnlib/__main__.py,sha256=A1FMFZQf5RZaceQ1p0QkneOIkRZK1HZ_93L73QC4wBY,1465
+vnnlib/__version__.py,sha256=3EXaFnXv1z-8AVCGrDM9MpCrpg8I15YhcHCsHzX3iGI,24
+vnnlib/compat.py,sha256=zpEsdqLf1oWBoDAZlZ_Etp2IYtiZfFNb44zrrWuIhCg,9725
+vnnlib/errors.py,sha256=1FNvtN977kBeNE6l0VwqF4nPZuTfZyS6V2NsdMmmtW4,385
+vnnlib/parser.py,sha256=4AHssf44RRiYh83TwTu9jehMD6UK-cq1n3YhUGAiSvA,11227
+vnnlib-0.0.1a2.dist-info/LICENSE.txt,sha256=-XL5dew5SUKD_JytQcjChPYEUOkRzbKGjV2NOQfiWJk,1105
+vnnlib-0.0.1a2.dist-info/METADATA,sha256=B8r76gi17n59twGajuErGpuKLrm02E1R3AV6YZNCvX8,3850
+vnnlib-0.0.1a2.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
+vnnlib-0.0.1a2.dist-info/top_level.txt,sha256=lYFo9TDo2Pzkutd_gdOp3mv-cQ9HwisEMB8GC9mX9uI,7
+vnnlib-0.0.1a2.dist-info/RECORD,,

vnnlib-0.0.1a0.dist-info/RECORD

@@ -1,8 +0,0 @@
-vnnlib/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-vnnlib/__main__.py,sha256=_AJDw4czH0hCK-fAZqjnOwpJo3TmCBEWPA0WOLBx-e0,316
-vnnlib/__version__.py,sha256=508eDu4nPCyqYyg_NQBRjRZmK_68ggYywDmqDMXRF1I,24
-vnnlib-0.0.1a0.dist-info/LICENSE.txt,sha256=-XL5dew5SUKD_JytQcjChPYEUOkRzbKGjV2NOQfiWJk,1105
-vnnlib-0.0.1a0.dist-info/METADATA,sha256=dMmYNMksAuyiHeakhviSbfL69t_c3VeKWZuY8cLzOoA,2178
-vnnlib-0.0.1a0.dist-info/WHEEL,sha256=2wepM1nk4DS4eFpYrW1TTqPcoGNfHhhO_i5m4cOimbo,92
-vnnlib-0.0.1a0.dist-info/top_level.txt,sha256=lYFo9TDo2Pzkutd_gdOp3mv-cQ9HwisEMB8GC9mX9uI,7
-vnnlib-0.0.1a0.dist-info/RECORD,,