vnnlib-test-solver 2.0.0__py3-none-any.whl

vnnlib_test_solver/verify.py

@@ -0,0 +1,417 @@
+"""The verify command, per standard section 5.3.
+
+Section 5.3 fixes the shape of the command::
+
+    <solver> verify <filepath> [--network <name>=<filepath>]
+                               [--timeout <seconds>]
+                               [--serialise-assignments <filepath>]
+
+Nothing here opens the query file. A request is a record of what was asked
+for, and which rule answers it is decided by the file's name alone. The one
+function that needs the query's contents is handed a model that has already
+been read, so the parser stays behind the single module that imports it.
+
+Section 5.3 permits a solver to add its own arguments so long as they are
+optional. This one adds none: on a conformance baseline, every spelling that is
+not in the standard is surface a consumer can come to depend on.
+"""
+
+from __future__ import annotations
+
+import argparse
+import time
+from collections.abc import Mapping, Sequence
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+from .errors import ConfigError, UsageError
+from .querymodel import QueryModel
+from .rules import Rule
+from .spec import REAL, TIMED_OUT
+from .validation import MAX_WAIT_SECONDS
+
+VERIFY_COMMAND = "verify"
+
+QUERY_ARGUMENT = "<filepath>"
+NETWORK_OPTION = "--network"
+TIMEOUT_OPTION = "--timeout"
+SERIALISE_ASSIGNMENTS_OPTION = "--serialise-assignments"
+
+SERIALISE_ASSIGNMENTS_ALIAS = "--assignments"
+"""Section 5.3's usage block spells the option this way, while its own option
+description and section 5.4.3 both spell it --serialise-assignments. Which one a
+conformant solver must accept is an open question with the client, so both are
+accepted and the longer spelling is the documented one; that way neither reading
+of the standard breaks a consumer. *Assumption*, pending an answer."""
+
+VERIFY_OPTIONS = (NETWORK_OPTION, TIMEOUT_OPTION, SERIALISE_ASSIGNMENTS_OPTION)
+"""The options section 5.3 defines, in the order it lists them.
+
+A tuple rather than a set: this order reaches stderr in the message naming the
+legal options, and unordered iteration in emitted output is not permitted.
+"""
+
+
+@dataclass(frozen=True)
+class VerifyRequest:
+    """One well-formed invocation of the verify command.
+
+    ``networks`` keeps command-line order rather than sorting: it is emitted in
+    error messages about the mapping, and a sort would make the wording depend on
+    the names rather than on what the caller wrote.
+    """
+
+    query: Path
+    networks: Mapping[str, Path]
+    timeout: Optional[int]
+    serialise_assignments: Optional[Path]
+
+
+def add_arguments(command: argparse.ArgumentParser) -> None:
+    """Declare the section 5.3 arguments on the verify sub-parser."""
+    command.add_argument(
+        "query",
+        metavar=QUERY_ARGUMENT,
+        help="path to the VNN-LIB query file to verify",
+    )
+    command.add_argument(
+        NETWORK_OPTION,
+        metavar="<name>=<filepath>",
+        action="append",
+        dest="networks",
+        default=[],
+        help=(
+            "map a declared network to an ONNX model file; given once for each "
+            "network declared without an equal-to"
+        ),
+    )
+    # type=int makes argparse itself reject a non-integer, which exits through the
+    # parser's own error() and so already carries this package's usage exit code.
+    # It does not reject a negative, which parses cleanly and means nothing, so the
+    # range is checked separately and refused in this package's own wording.
+    command.add_argument(
+        TIMEOUT_OPTION,
+        metavar="<seconds>",
+        type=int,
+        help="whole seconds to allow before the solver answers timed-out",
+    )
+    command.add_argument(
+        SERIALISE_ASSIGNMENTS_OPTION,
+        metavar="<filepath>",
+        dest="serialise_assignments",
+        help="folder to write serialised assignments into, instead of stdout",
+    )
+    command.add_argument(
+        SERIALISE_ASSIGNMENTS_ALIAS,
+        metavar="<filepath>",
+        dest="serialise_assignments",
+        help=argparse.SUPPRESS,
+    )
+
+
+def request_from(args: argparse.Namespace) -> VerifyRequest:
+    """Build a request from parsed arguments, refusing what argparse cannot.
+
+    Raises:
+        UsageError: the arguments parsed but do not describe a usable request.
+    """
+    # argparse accepts an empty string for a positional, so this is the only place
+    # it can be refused. A file with no name cannot exist, and matching it against
+    # a catch-all pattern would otherwise produce a confident answer about nothing.
+    if not args.query:
+        raise UsageError(
+            f"the {QUERY_ARGUMENT} argument must not be empty; {VERIFY_COMMAND} "
+            f"needs the path to a query file"
+        )
+
+    timeout = args.timeout
+    if timeout is not None and timeout < 0:
+        raise UsageError(
+            f"{TIMEOUT_OPTION} must be zero or more whole seconds, not {timeout}"
+        )
+    # Above this the wait itself raises, and an unhandled exception reaches the
+    # caller as a traceback rather than as a message. See MAX_WAIT_SECONDS.
+    if timeout is not None and timeout > MAX_WAIT_SECONDS:
+        raise UsageError(
+            f"{TIMEOUT_OPTION} must be at most {MAX_WAIT_SECONDS} seconds; "
+            f"{timeout} is longer than this package can wait"
+        )
+
+    networks: dict[str, Path] = {}
+    for token in args.networks:
+        name, path = _network_pair(token)
+        if name in networks:
+            raise UsageError(
+                f"{NETWORK_OPTION} maps {name!r} more than once; each declared "
+                f"network takes exactly one model file"
+            )
+        networks[name] = path
+
+    serialise_assignments = args.serialise_assignments
+    return VerifyRequest(
+        query=Path(args.query),
+        networks=networks,
+        timeout=timeout,
+        serialise_assignments=(
+            None if serialise_assignments is None else Path(serialise_assignments)
+        ),
+    )
+
+
+def warnings(request: VerifyRequest) -> tuple[str, ...]:
+    """Report anything asked for that this build will not actually do.
+
+    Serialising assignments is optional in the standard and is not implemented
+    yet, but the option is accepted so that the published argument surface is the
+    one section 5.3 defines. Accepting it and silently doing nothing is the
+    dangerous half of that: a caller testing serialisation would see a zero exit,
+    no files, and no explanation, which reads as a pass.
+
+    A warning rather than an error, because the run still delivers a correct
+    result line and the standard makes command-line output the default that every
+    solver must support regardless of serialisation. Returned rather than printed,
+    the way the configuration warnings are, so this stays testable without
+    capturing a stream.
+    """
+    if request.serialise_assignments is None:
+        return ()
+    return (
+        f"{SERIALISE_ASSIGNMENTS_OPTION} was given, but writing assignment files "
+        f"is not implemented yet, so nothing was written to "
+        f"{request.serialise_assignments}; the result is still on stdout",
+    )
+
+
+def answer(request: VerifyRequest, rule: Rule) -> str:
+    """Wait as long as the rule asks for, then return the result to print.
+
+    A rule's delay is how long the solver claims to spend thinking, and the
+    caller's timeout is how long it is willing to wait. When the delay outlasts
+    the timeout the answer is ``timed-out``, and the wait is the timeout rather
+    than the delay: the run then finishes on the caller's deadline, which is the
+    only way a caller enforcing its own can be tested against this binary at all.
+
+    Waiting the whole timeout rather than returning at once is the point. A
+    solver that answers ``timed-out`` instantly is not one anybody's timeout
+    handling can be exercised against.
+
+    A delay exactly equal to the timeout answers rather than times out. The
+    timeout is where waiting has gone on too long, and waiting exactly that long
+    has not gone on too long yet.
+    """
+    if request.timeout is not None and rule.delay_seconds > request.timeout:
+        time.sleep(request.timeout)
+        return TIMED_OUT
+
+    time.sleep(rule.delay_seconds)
+    return rule.result
+
+
+def is_real_valued(model: QueryModel) -> bool:
+    """Whether the query is real-valued: every declaration written ``real``.
+
+    Section 3.5 defines a real-valued query as one that *"must exclusively use
+    the special real element type"*, and section 5.3.2 exempts such a query
+    from two of its three error conditions. Both conditions ask the same
+    question, so they ask it in one place: a single definition cannot come to
+    disagree with itself about what "the query uses real" means.
+
+    A query declaring nothing would answer ``True`` here on an empty ``all``.
+    The grammar makes that unreachable - every network declares at least one
+    input and one output - so it is left as the vacuous truth rather than
+    guarded against, and named here so the next reader does not have to work
+    out whether it was overlooked.
+    """
+    return all(declaration.element_type == REAL for declaration in model.declarations)
+
+
+def check_network_mapping(request: VerifyRequest, model: QueryModel) -> None:
+    """Enforce section 5.3.2's first error condition on the supplied mapping.
+
+    One model file per declared network, except a network declared equivalent
+    to another, which is verified by verifying the network it copies and so
+    needs no model of its own. Its variables still appear in the assignment;
+    only this mapping exempts it.
+
+    The two directions are reported separately, and a name supplied for an
+    equivalent network is separated from a name the query never declares,
+    because a caller who gets one of those wrong has made a different mistake
+    from a caller who gets the other wrong. A single "wrong number of models"
+    message would also let a test pass against a solver that simply refused
+    everything.
+
+    Both lists are walked in a fixed order - declarations in the order the
+    query makes them, supplied names in the order the command line gave them -
+    so the message names the same network every time for the same invocation.
+
+    Raises:
+        UsageError: the supplied model files do not match the declarations.
+    """
+    equivalences = {network.name: network.equal_to for network in model.networks}
+    required = [name for name, equal_to in equivalences.items() if equal_to is None]
+
+    for name in request.networks:
+        if name not in equivalences:
+            raise UsageError(
+                f"{NETWORK_OPTION} maps {name!r}, which {model.path} does not "
+                f"declare; a model file is supplied for each declared network"
+            )
+        if equivalences[name] is not None:
+            raise UsageError(
+                f"{NETWORK_OPTION} maps {name!r}, which {model.path} declares equal "
+                f"to {equivalences[name]!r}; an equivalent network is verified by "
+                f"verifying the one it copies, so it takes no model file of its own"
+            )
+
+    for name in required:
+        if name not in request.networks:
+            raise UsageError(
+                f"no model file was supplied for network {name!r}, which "
+                f"{model.path} declares; give {NETWORK_OPTION} {name}=<filepath> "
+                f"once for each declared network not declared equal to another"
+            )
+
+
+def check_element_types(
+    model: QueryModel, model_element_types: Mapping[str, str]
+) -> None:
+    """Enforce section 5.3.2's second error condition on the supplied models.
+
+    The clause is that the element types in the provided ONNX model files must
+    match the types the query declares, and that a query written in ``real`` is
+    exempt. Nothing here opens a model file, so the types the models expose
+    come from the configuration and the types they are checked against come
+    from the query. Configuration claims; the query decides.
+
+    **The exemption is a property of the whole query, not of each declaration.**
+    Section 3.5 says a real-valued query *"must exclusively use the special real
+    element type"*, so a query mixing ``real`` with any other type is not a
+    real-valued query and nothing in it is exempt - including the ``real``
+    declarations themselves. A query written entirely in ``real`` is exempt in
+    full and is not checked at all.
+
+    The parser does not enforce exclusivity: a mixed query parses cleanly with
+    both types intact, verified by running it. That is why the granularity had
+    to be decided rather than inherited. Mixing is still not refused here - this
+    clause governs whether the exemption applies, not whether the query is
+    legal, and refusing it outright would invent a rejection 5.3.2's closing
+    paragraph leaves to discretion.
+
+    A variable the configuration does not name is taken to match. The table is
+    a claim about specific variables rather than a complete description of a
+    file nobody reads, and an unnamed variable is one the configuration makes
+    no claim about. This is why it differs from the assignment values, which
+    must be complete: those are printed, and a short block would be
+    indistinguishable from a whole one, whereas nothing here reaches stdout.
+
+    Declarations are walked in the order the query makes them, so the same
+    invocation names the same variable every time.
+
+    Raises:
+        UsageError: a declared type and the model's type disagree.
+        ConfigError: the configuration names a variable the query does not
+            declare, which is the configuration author's mistake rather than
+            the caller's.
+    """
+    if not model_element_types:
+        return
+
+    if is_real_valued(model):
+        return
+
+    declared = {declaration.name: declaration for declaration in model.declarations}
+    # Sorted, because this is a set difference and the message must not depend
+    # on iteration order. Declaration order cannot be recovered for a name the
+    # query never declared.
+    unknown = sorted(set(model_element_types) - set(declared))
+    if unknown:
+        raise ConfigError(
+            f"the rule states a model element type for {unknown[0]!r}, which "
+            f"{model.path} does not declare; a rule states what the model files "
+            f"expose, and the query decides which variables exist"
+        )
+
+    for declaration in model.declarations:
+        exposed = model_element_types.get(declaration.name)
+        if exposed is None or exposed == declaration.element_type:
+            continue
+        raise UsageError(
+            f"the model for network {declaration.network!r} exposes "
+            f"{declaration.name!r} as {exposed}, but {model.path} declares it "
+            f"{declaration.element_type}; a declared type and a model's type must "
+            f"agree unless the query is written entirely in {REAL}"
+        )
+
+
+def check_soundness(model: QueryModel, sound_for: Optional[Sequence[str]]) -> None:
+    """Enforce section 5.3.2's third error condition on the declared types.
+
+    The clause is that a solver incapable of sound analysis over a declared
+    type must error, and that a user consents to unsound analysis by rewriting
+    the query to use ``real``. Which types this solver claims to analyse
+    soundly is ``[soundness] sound-for``, so the condition is triggerable on
+    demand - which is the point, because it is otherwise close to impossible to
+    provoke against a real verifier.
+
+    **Consent is given by the whole query, not by one declaration.** Section
+    3.5's real-valued query uses ``real`` exclusively, and 5.3.2 asks the user
+    to consent by *rewriting the query* - both of which describe a file rather
+    than a variable. So a query written entirely in ``real`` is not checked at
+    all, and in a query that mixes types every declaration is checked against
+    the claim, the ``real`` ones included. A configuration that wants a mixed
+    query to pass says so by listing ``real`` in ``sound-for``, which is the
+    same explicit claim every other type needs.
+
+    **A configuration with no soundness table is not checked at all**, and that
+    is a decision rather than an oversight. Read the other way, silence would
+    be a claim of total unsoundness, and every configuration that has never
+    mentioned the subject would refuse every query it was given. That is not
+    the conservative reading of an optional table, it is the most destructive
+    one. An explicitly empty ``sound-for``
+    **is** a claim, and refuses everything not written in ``real``, which is
+    exactly the fixture a caller needs to trigger this condition.
+
+    The claimed types are listed in the order the configuration writes them,
+    matching the section 5.4.1 warning, so the message is identical between
+    runs.
+
+    Raises:
+        UsageError: a declared type is one this configuration does not claim to
+            analyse soundly, and consent was not given by declaring it ``real``.
+    """
+    if sound_for is None:
+        return
+
+    if is_real_valued(model):
+        return
+
+    claimed = set(sound_for)
+    for declaration in model.declarations:
+        if declaration.element_type in claimed:
+            continue
+        listed = ", ".join(sound_for) if sound_for else "no element type at all"
+        raise UsageError(
+            f"{model.path} declares {declaration.name!r} in network "
+            f"{declaration.network!r} as {declaration.element_type}, which this "
+            f"solver does not claim to analyse soundly; it claims {listed}. "
+            f"Rewrite the query to use {REAL} throughout to consent to analysis "
+            f"that may be unsound"
+        )
+
+
+def _network_pair(token: str) -> tuple[str, Path]:
+    """Split one --network value into the name it maps and the file it maps to.
+
+    Three ways to get this wrong - no '=' at all, no name before it, no path
+    after it - share one message, because they share one cause: the value is not
+    a pair. Splitting on the first '=' rather than the last is deliberate; a
+    network name cannot contain one, and a file name can.
+    """
+    name, separator, path = token.partition("=")
+    if not separator or not name or not path:
+        raise UsageError(
+            f"{NETWORK_OPTION} takes <name>=<filepath>; {token!r} is not a network "
+            f"name and a file path separated by '='"
+        )
+    return name, Path(path)

vnnlib_test_solver-2.0.0.dist-info/METADATA

@@ -0,0 +1,176 @@
+Metadata-Version: 2.5
+Name: vnnlib-test-solver
+Version: 2.0.0
+Summary: A configurable test solver implementing the VNN-LIB standard's command-line interface.
+Project-URL: Homepage, https://github.com/VNNLIB/VNNLIB-Test-Solver
+Project-URL: Repository, https://github.com/VNNLIB/VNNLIB-Test-Solver
+Project-URL: Changelog, https://github.com/VNNLIB/VNNLIB-Test-Solver/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/VNNLIB/VNNLIB-Test-Solver/issues
+Author: VNNLIB
+License-Expression: MIT
+License-File: LICENSE
+Keywords: conformance,neural-network,testing,verification,vnnlib
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.9
+Requires-Dist: tomli>=2.0; python_version < '3.11'
+Requires-Dist: vnnlib==1.0.2
+Provides-Extra: dev
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Provides-Extra: serialise
+Requires-Dist: onnx; extra == 'serialise'
+Description-Content-Type: text/markdown
+
+# VNNLIB-Test-Solver
+
+[![Build-and-Test](https://github.com/VNNLIB/VNNLIB-Test-Solver/actions/workflows/buildAndTest.yml/badge.svg)](https://github.com/VNNLIB/VNNLIB-Test-Solver/actions/workflows/buildAndTest.yml)
+
+A configurable test solver for the [VNN-LIB](https://www.vnnlib.org/) standard. It
+implements the command-line interface defined in Chapter 5 and answers entirely from a
+configuration file, performing no verification of its own. It exists to give tools that
+drive VNN-LIB solvers, in particular the `vnnlib.solver` interface, a solver whose
+responses are fully controlled and reproducible.
+
+Team 23, CITS3200 Professional Computing, The University of Western Australia.
+Client: Dr Matthew Daggitt.
+
+## Features
+
+- Every answer comes from a TOML file. One binary gives three different solvers three
+  different behaviours with no code change.
+- The `verify` command, returning any of `sat`, `unsat`, `unknown` or `timed-out`, chosen
+  by matching the query file's name.
+- The satisfying assignment of section 5.3.1, printed in the command-line format and
+  compared byte for byte against the standard's own worked example, with one deliberate
+  departure where that example contradicts its own declarations. The
+  [reference](https://github.com/VNNLIB/VNNLIB-Test-Solver/blob/main/docs/CONFIGURATION.md#coverage-of-the-standards-command-line-chapter)
+  gives the four lines and why.
+- The `supports` command, answering all eleven mandatory capabilities in the four
+  response shapes the standard defines.
+- All three of the error conditions section 5.3.2 requires, each distinguishable from the
+  others.
+- A configurable delay, so a caller's timeout handling can be exercised without a solver
+  that genuinely takes minutes.
+- Four controls that make the solver misbehave on request: unparseable output, an exit
+  status disagreeing with the answer, noise on `stderr`, and abnormal termination.
+
+**Not implemented:** `--serialise-assignments` is accepted but writes no files. That is
+conformant rather than a gap - the standard requires the option only of a solver that
+reports supporting it, and this one reports `false`. The
+[coverage table](https://github.com/VNNLIB/VNNLIB-Test-Solver/blob/main/docs/CONFIGURATION.md#coverage-of-the-standards-command-line-chapter)
+gives the clause.
+
+## Installation
+
+```bash
+pip install vnnlib-test-solver
+```
+
+To work on the package instead, install it from a clone of this repository with
+`pip install .`, or `pip install -e ".[dev]"` to run its tests.
+
+Python 3.9 or later. The package is pure Python; its one runtime dependency, the
+standard's own `vnnlib` parser, is a compiled extension that publishes prebuilt wheels,
+so on Linux `x86_64`, macOS and Windows an install needs no compiler, CMake or pybind11.
+
+**There is no Linux `aarch64` wheel for the pinned version.** On arm64 Linux `pip install`
+falls through to building the parser from source and does need that toolchain. It is named
+here because it presents as a compiler error inside somebody else's package, which nobody
+traces back to a readme. See
+[Requirements](https://github.com/VNNLIB/VNNLIB-Test-Solver/blob/main/docs/CONFIGURATION.md#requirements) for the platform table.
+
+## Basic Usage
+
+**This solver has no default behaviour.** It answers only from a configuration file, and
+running it without one is an error rather than a fallback. That applies to `--name` and
+`--version` as much as to `verify`.
+
+The smallest configuration that answers all four commands below:
+
+```toml
+[solver]
+name = "My Test Solver"
+version = "1.0.0"
+
+[capabilities]
+onnx-element-types = ["real"]
+
+[[rules]]
+match = "*.vnnlib"
+result = "sat"
+```
+
+```bash
+vnnlibTestSolver --config my-solver.toml --name
+vnnlibTestSolver --config my-solver.toml --version
+vnnlibTestSolver --config my-solver.toml verify query.vnnlib
+vnnlibTestSolver --config my-solver.toml supports --onnx-element-types
+```
+
+`[solver]` and one rule are all that `verify`, `--name` and `--version` need. Each
+capability is answered from its own key, and one the file does not mention is an error
+rather than an empty answer, so `supports` needs the `[capabilities]` table as well.
+
+Runnable configurations covering the four results, the capability responses, the
+standard's worked example and the misbehaviour controls are in
+[`examples/`](https://github.com/VNNLIB/VNNLIB-Test-Solver/tree/main/examples/).
+
+A run resolves its configuration from `--config`, then the `VNNLIB_TEST_SOLVER_CONFIG`
+environment variable, then a `vnnlibTestSolver.toml` in the working directory. There is no
+fourth source and no default: if none resolves, the run exits `2` with nothing on
+`stdout`. Every answer this solver gives is one somebody chose, so with no configuration
+there is nothing it can honestly say.
+
+## Documentation
+
+- **[Configuration reference](https://github.com/VNNLIB/VNNLIB-Test-Solver/blob/main/docs/CONFIGURATION.md)** - the complete surface: rules and
+  matching, model files, element types and soundness, satisfying assignments, capability
+  queries, the misbehaviour controls, configuration discovery, exit codes, and the
+  guarantees about what reaches `stdout`. It also carries a clause-by-clause table of what
+  Chapter 5 requires and what this package does with each requirement.
+- **[CONTRIBUTING.md](https://github.com/VNNLIB/VNNLIB-Test-Solver/blob/main/CONTRIBUTING.md)** - working on the package: setting up, running the
+  checks, how correctness is established here, and how a release is made.
+- **[CHANGELOG.md](https://github.com/VNNLIB/VNNLIB-Test-Solver/blob/main/CHANGELOG.md)** - what changed in each version, and why.
+
+## Output guarantees
+
+Three properties a caller can rely on, each covered by tests that read raw bytes:
+
+- The result is the **first line of `stdout`**, and `stdout` carries nothing else that is
+  not a response the standard defines. Warnings and errors go to `stderr`. The one
+  exception has to be asked for by name: a configuration setting `raw_stdout` replaces
+  `stdout` deliberately, which is how a caller produces output its own parser should
+  reject.
+- Line endings on `stdout` are **`LF` on every platform**, Windows included, so a recorded
+  response compares byte for byte across machines.
+- Output is **deterministic**: the same configuration and query produce byte-identical
+  `stdout` every time. No timestamp, duration, random value, set or hash ordering ever
+  reaches it.
+
+## Version compatibility
+
+| VNNLIB-Test-Solver version | VNNLIB version |
+| --- | --- |
+| v2.0.0 | v2.0 |
+| v1.0.0 | v2.0 |
+
+## Related repositories
+
+- [VNNLIB-Standard](https://github.com/VNNLIB/VNNLIB-Standard) - the specification
+- [VNNLIB-CPP](https://github.com/VNNLIB/VNNLIB-CPP) - the C++ parser library
+- [VNNLIB-Python](https://github.com/VNNLIB/VNNLIB-Python) - the Python bindings
+
+## Licence
+
+MIT. See `LICENSE`.

vnnlib_test_solver-2.0.0.dist-info/RECORD

@@ -0,0 +1,19 @@
+vnnlib_test_solver/__init__.py,sha256=_7OlQdbVkK4jad0CLdpI0grT-zEAb-qgFmH5mFzDXiA,22
+vnnlib_test_solver/assignments.py,sha256=Vqr3eQ--3F2WASs9hFr7qgF6iFTjiKY2kzkQ0mB6Itc,6828
+vnnlib_test_solver/cli.py,sha256=uSHXX0jz_UnltQE4ii2_UN-TvEyEltP66WW5VtWa7X0,20964
+vnnlib_test_solver/config.py,sha256=mXO4qO_OTMNs38pucMwww-2o122UnJTRWHmeDyJZUh0,4287
+vnnlib_test_solver/dtypes.py,sha256=k2DSRD3UxwUHk-EweZG3kzg97ZYsVAK_BDwcRJIUm_4,2336
+vnnlib_test_solver/errors.py,sha256=K_l6E3UNh9FYGdA_S3U9yLbhkrdsuYTg2MOBclb8-8s,1124
+vnnlib_test_solver/injection.py,sha256=NvW6bKT7yRjcYS7zhKEf93oIb5uM5J1cJJ4AEL3fZP8,5265
+vnnlib_test_solver/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vnnlib_test_solver/querymodel.py,sha256=GKWHC-HSlnIA7v8al1u4qeSZ8KUIT3XlwDKXRHumOO4,10058
+vnnlib_test_solver/rules.py,sha256=v-GERh8D_1pVO4Y0iX6vN47excsNxE-3LHz4jqwt4tg,4520
+vnnlib_test_solver/spec.py,sha256=kXWo8ocGA9jbAiqFThRvQ5XE3Rnn1gfiPbf_LKCENOo,2644
+vnnlib_test_solver/supports.py,sha256=_pNvS84Fjo3AI7AU8pksFHuPoNkT6L46mCpWFAa4ugE,5716
+vnnlib_test_solver/validation.py,sha256=IcEqV6M7qVe8hSgP-8bp1qEbANv2zjPkVMH_HA7TIv4,22180
+vnnlib_test_solver/verify.py,sha256=2R9mptYnSkWBA7xVSy_QiytDMzVESfXtuWgKriVS-B0,18455
+vnnlib_test_solver-2.0.0.dist-info/METADATA,sha256=CGiDhHY3FR2ghcuV3AmXMTqEYJ_5GSwt8BeTvGNRsRk,8275
+vnnlib_test_solver-2.0.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+vnnlib_test_solver-2.0.0.dist-info/entry_points.txt,sha256=55Kn5rWOJ5bzFvsg4FkkTDgDg7qXlMukk9t_BrMV6dk,65
+vnnlib_test_solver-2.0.0.dist-info/licenses/LICENSE,sha256=b5q7ljPaPaT4WAN2VLPai3V7cni78Q5xSzpgXJ5MJ10,1063
+vnnlib_test_solver-2.0.0.dist-info/RECORD,,

vnnlib_test_solver-2.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

vnnlib_test_solver-2.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+vnnlibTestSolver = vnnlib_test_solver.cli:main

vnnlib_test_solver-2.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 VNNLIB
+
+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.