entail-ai 0.1.0__tar.gz

entail_ai-0.1.0/LICENSE

@@ -0,0 +1,202 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
+

entail_ai-0.1.0/PKG-INFO

@@ -0,0 +1,161 @@
+Metadata-Version: 2.4
+Name: entail-ai
+Version: 0.1.0
+Summary: Keep what a value means intact across LLM inference-stack boundaries: declare it, check it against the data, and resolve a mismatch before it becomes a silent wrong answer
+Author: wwoosshh
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/wwoosshh/entail
+Project-URL: Issues, https://github.com/wwoosshh/entail/issues
+Keywords: llm,inference,vllm,sglang,transformers,correctness,rope,silent-errors
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# entail
+
+**Keep what a value means intact across LLM inference-stack boundaries.**
+
+An inference stack is a chain of parts — checkpoint and config, loader, engine, kernels, quantization, cache.
+Each part can be correct on its own terms while the *meaning* of a value is lost between two of them: a declared
+property the chosen kernel ignores, a setting that arrives under a name nobody reads any more, a cache that
+silently loses a token. The output is then wrong, fluently and without a warning.
+
+entail declares what a value means where it crosses a boundary, checks the declaration against the real thing,
+and when they disagree **it resolves the mismatch first** — routes the value to a consumer that honours it, or
+converts it to the form the consumer reads — and prints one line saying what it changed. It stops only when no
+fix exists.
+
+The name is the logical sense of *entail*: what a checkpoint declares must entail what the engine executes.
+(ent·**AI**·**L** — an AI library.)
+
+> Status: research prototype (alpha). Measured on one RTX 4070 Ti with the versions under "Tested with".
+
+## Why: a case measured end to end
+
+Restating a model's **own** `rope_scaling` at launch — the route model cards give for enabling YaRN — drops
+`rope_theta` under transformers 5, and the engine silently falls back to a RoPE base of 10,000.
+
+Llama-3.2-3B-Instruct, greedy, GSM8K (first 500 on vLLM, first 200 on SGLang):
+
+| | untouched | same `rope_scaling` passed again at launch | with entail |
+|---|---|---|---|
+| vLLM 0.30.0 `--hf-overrides` | 379 / 500 | **279 / 500**, no warning | 378 / 500 |
+| SGLang 0.5.20 `--json-model-override-args` | 161 / 200 | **106 / 200** | 161 / 200 (outputs identical) |
+
+The degraded runs are identical to an explicit `rope_theta = 10000`. Outputs stay fluent; the answers are wrong.
+Qwen3 dense models happen to be safe because those model files fill in 1,000,000; Llama, Qwen3-MoE, Gemma and
+others do not.
+
+## Install
+
+```bash
+pip install "git+https://github.com/wwoosshh/entail"
+```
+
+Install it into the same environment as your engine (vLLM, SGLang or transformers). entail has no dependencies
+of its own. Once it is on PyPI: `pip install entail-ai` (the import name stays `entail`). `uv pip install` works
+the same way.
+
+Check what it sees:
+
+```bash
+entail doctor
+```
+
+## Use
+
+Turn it on with one environment variable; nothing else changes.
+
+```bash
+ENTAIL=load vllm serve meta-llama/Llama-3.2-3B-Instruct --hf-overrides '{"rope_scaling": {...}}'
+ENTAIL=load python -m sglang.launch_server --model-path ... --json-model-override-args '{...}'
+ENTAIL=load python your_transformers_script.py
+```
+
+When it changes something, it says so:
+
+```
+[entail] resolved LlamaConfig.rope_scaling was given after the config was built; it replaces rope_parameters and
+would have dropped rope_theta=500000.0, ...; kept it, as config.json would
+```
+
+From inside a script:
+
+```python
+import entail
+entail.enable()          # mode="load", policy="resolve"; child processes inherit it
+```
+
+### How it reaches engine worker processes
+
+vLLM and SGLang run the model in processes they start themselves. `pip install` puts one file,
+`entail-autoinstall.pth`, into site-packages; Python reads it at every start-up. Its single line checks the
+environment and does nothing unless `ENTAIL` is set. `entail hook status|install|uninstall` shows or manages it
+(an editable install does not place it — run `entail hook install`).
+
+## What it does
+
+**Resolves**
+
+| mismatch | resolution | measured |
+|---|---|---|
+| a RoPE value given under its transformers-4 name after the config is built (`rope_theta`, `rope_scaling` — keyword to `from_pretrained`, attribute, vLLM `--hf-overrides`, SGLang `--json-model-override-args`) | written where `config.json` would have put it, including per-layer-type RoPE (asks the config class) | equal to the `config.json` route on 4 model families × 2 routes × 3 values; GSM8K restored (table above) |
+| an attention backend that drops a declared model property (e.g. Gemma 2 logit soft-capping on transformers `sdpa`, SGLang `flashinfer`) | switched to a backend measured to honour it (`eager`, `triton`) | tokens equal the reference run; cost 1.18× (transformers), 1.13× (SGLang, the backend's own price) |
+
+**Checks** (and stops, when nothing can resolve it)
+
+- attention properties against each engine's backends, before any weight is read
+- config keys that would be swallowed, and tied-embedding declarations against the checkpoint
+- vLLM weights after repacking: layout, stride and a value sample against the declared transform
+- weights in memory against the checkpoint file (`ENTAIL_SOURCE=1`)
+- the KV cache contract (a request holds what it needs, nothing shrank) on transformers, vLLM's paged cache
+  and SGLang
+
+`entail preflight --model /path/to/model --engine sglang --list` runs the start-up checks without starting a server.
+
+## Configuration
+
+| variable | values | meaning |
+|---|---|---|
+| `ENTAIL` | `off` (default), `load`, `debug` | `load`: start-up checks and resolvers; `debug`: also every declared boundary, and uncovered cases become errors |
+| `ENTAIL_POLICY` | `resolve` (default), `refuse` | `refuse` stops at the first mismatch instead of resolving |
+| `ENTAIL_ONLY` | e.g. `rope_alias,sglang_adapter` | install only these adapters |
+| `ENTAIL_VERBOSE` | `1` | print each adapter as it is installed |
+| `ENTAIL_SOURCE` | `1` | also compare loaded weights with the checkpoint file (vLLM, a little I/O at start-up) |
+| `ENTAIL_SEED` | test names | fault injection used to test the checks themselves; never set it in production |
+
+## Tested with
+
+transformers 5.12.1 and 5.17.0, vLLM 0.30.0, SGLang 0.5.20, torch 2.13–2.14, Python 3.12, one RTX 4070 Ti
+(12 GB). Other versions may work; `entail doctor` prints what is installed. On transformers 4.x the RoPE resolver
+has nothing to do and stays out of the way.
+
+The capability table (which backend honours what) records its evidence per entry, and only entries marked
+*measured* are used as resolution targets. The measurement scripts and raw results are kept in the author's
+research workspace and are not in this repository yet.
+
+## Development
+
+```bash
+git clone https://github.com/wwoosshh/entail && cd entail
+pip install -e .
+entail hook install          # editable installs do not place the start-up hook
+PYTHON=python bash tests/run_all.sh
+```
+
+Tests that need a local model look in `ENTAIL_TEST_MODELS` (default `~/models`) and skip when it is absent.
+
+한국어 안내: [README.ko.md](README.ko.md)
+
+## License
+
+See [LICENSE](LICENSE).

entail_ai-0.1.0/README.md

@@ -0,0 +1,139 @@
+# entail
+
+**Keep what a value means intact across LLM inference-stack boundaries.**
+
+An inference stack is a chain of parts — checkpoint and config, loader, engine, kernels, quantization, cache.
+Each part can be correct on its own terms while the *meaning* of a value is lost between two of them: a declared
+property the chosen kernel ignores, a setting that arrives under a name nobody reads any more, a cache that
+silently loses a token. The output is then wrong, fluently and without a warning.
+
+entail declares what a value means where it crosses a boundary, checks the declaration against the real thing,
+and when they disagree **it resolves the mismatch first** — routes the value to a consumer that honours it, or
+converts it to the form the consumer reads — and prints one line saying what it changed. It stops only when no
+fix exists.
+
+The name is the logical sense of *entail*: what a checkpoint declares must entail what the engine executes.
+(ent·**AI**·**L** — an AI library.)
+
+> Status: research prototype (alpha). Measured on one RTX 4070 Ti with the versions under "Tested with".
+
+## Why: a case measured end to end
+
+Restating a model's **own** `rope_scaling` at launch — the route model cards give for enabling YaRN — drops
+`rope_theta` under transformers 5, and the engine silently falls back to a RoPE base of 10,000.
+
+Llama-3.2-3B-Instruct, greedy, GSM8K (first 500 on vLLM, first 200 on SGLang):
+
+| | untouched | same `rope_scaling` passed again at launch | with entail |
+|---|---|---|---|
+| vLLM 0.30.0 `--hf-overrides` | 379 / 500 | **279 / 500**, no warning | 378 / 500 |
+| SGLang 0.5.20 `--json-model-override-args` | 161 / 200 | **106 / 200** | 161 / 200 (outputs identical) |
+
+The degraded runs are identical to an explicit `rope_theta = 10000`. Outputs stay fluent; the answers are wrong.
+Qwen3 dense models happen to be safe because those model files fill in 1,000,000; Llama, Qwen3-MoE, Gemma and
+others do not.
+
+## Install
+
+```bash
+pip install "git+https://github.com/wwoosshh/entail"
+```
+
+Install it into the same environment as your engine (vLLM, SGLang or transformers). entail has no dependencies
+of its own. Once it is on PyPI: `pip install entail-ai` (the import name stays `entail`). `uv pip install` works
+the same way.
+
+Check what it sees:
+
+```bash
+entail doctor
+```
+
+## Use
+
+Turn it on with one environment variable; nothing else changes.
+
+```bash
+ENTAIL=load vllm serve meta-llama/Llama-3.2-3B-Instruct --hf-overrides '{"rope_scaling": {...}}'
+ENTAIL=load python -m sglang.launch_server --model-path ... --json-model-override-args '{...}'
+ENTAIL=load python your_transformers_script.py
+```
+
+When it changes something, it says so:
+
+```
+[entail] resolved LlamaConfig.rope_scaling was given after the config was built; it replaces rope_parameters and
+would have dropped rope_theta=500000.0, ...; kept it, as config.json would
+```
+
+From inside a script:
+
+```python
+import entail
+entail.enable()          # mode="load", policy="resolve"; child processes inherit it
+```
+
+### How it reaches engine worker processes
+
+vLLM and SGLang run the model in processes they start themselves. `pip install` puts one file,
+`entail-autoinstall.pth`, into site-packages; Python reads it at every start-up. Its single line checks the
+environment and does nothing unless `ENTAIL` is set. `entail hook status|install|uninstall` shows or manages it
+(an editable install does not place it — run `entail hook install`).
+
+## What it does
+
+**Resolves**
+
+| mismatch | resolution | measured |
+|---|---|---|
+| a RoPE value given under its transformers-4 name after the config is built (`rope_theta`, `rope_scaling` — keyword to `from_pretrained`, attribute, vLLM `--hf-overrides`, SGLang `--json-model-override-args`) | written where `config.json` would have put it, including per-layer-type RoPE (asks the config class) | equal to the `config.json` route on 4 model families × 2 routes × 3 values; GSM8K restored (table above) |
+| an attention backend that drops a declared model property (e.g. Gemma 2 logit soft-capping on transformers `sdpa`, SGLang `flashinfer`) | switched to a backend measured to honour it (`eager`, `triton`) | tokens equal the reference run; cost 1.18× (transformers), 1.13× (SGLang, the backend's own price) |
+
+**Checks** (and stops, when nothing can resolve it)
+
+- attention properties against each engine's backends, before any weight is read
+- config keys that would be swallowed, and tied-embedding declarations against the checkpoint
+- vLLM weights after repacking: layout, stride and a value sample against the declared transform
+- weights in memory against the checkpoint file (`ENTAIL_SOURCE=1`)
+- the KV cache contract (a request holds what it needs, nothing shrank) on transformers, vLLM's paged cache
+  and SGLang
+
+`entail preflight --model /path/to/model --engine sglang --list` runs the start-up checks without starting a server.
+
+## Configuration
+
+| variable | values | meaning |
+|---|---|---|
+| `ENTAIL` | `off` (default), `load`, `debug` | `load`: start-up checks and resolvers; `debug`: also every declared boundary, and uncovered cases become errors |
+| `ENTAIL_POLICY` | `resolve` (default), `refuse` | `refuse` stops at the first mismatch instead of resolving |
+| `ENTAIL_ONLY` | e.g. `rope_alias,sglang_adapter` | install only these adapters |
+| `ENTAIL_VERBOSE` | `1` | print each adapter as it is installed |
+| `ENTAIL_SOURCE` | `1` | also compare loaded weights with the checkpoint file (vLLM, a little I/O at start-up) |
+| `ENTAIL_SEED` | test names | fault injection used to test the checks themselves; never set it in production |
+
+## Tested with
+
+transformers 5.12.1 and 5.17.0, vLLM 0.30.0, SGLang 0.5.20, torch 2.13–2.14, Python 3.12, one RTX 4070 Ti
+(12 GB). Other versions may work; `entail doctor` prints what is installed. On transformers 4.x the RoPE resolver
+has nothing to do and stays out of the way.
+
+The capability table (which backend honours what) records its evidence per entry, and only entries marked
+*measured* are used as resolution targets. The measurement scripts and raw results are kept in the author's
+research workspace and are not in this repository yet.
+
+## Development
+
+```bash
+git clone https://github.com/wwoosshh/entail && cd entail
+pip install -e .
+entail hook install          # editable installs do not place the start-up hook
+PYTHON=python bash tests/run_all.sh
+```
+
+Tests that need a local model look in `ENTAIL_TEST_MODELS` (default `~/models`) and skip when it is absent.
+
+한국어 안내: [README.ko.md](README.ko.md)
+
+## License
+
+See [LICENSE](LICENSE).

entail_ai-0.1.0/entail/__init__.py

@@ -0,0 +1,31 @@
+"""entail: keep what a value means intact across LLM inference-stack boundaries.
+
+Most users never import this: `pip install` puts a start-up hook in the environment, and `ENTAIL=load` turns it
+on for a process and every process it spawns (see README). `enable()` does the same from inside a script.
+"""
+import os
+
+from .core import (RoleError, boundary, check_config_keys, check_props, check_tied, facts_of, mode, policy, require,
+                   set_mode, set_policy, tag)
+from .facts import (LAYOUT_KINDS, KernelCaps, Layout, ModelProps, Positions, Quantized, Reduction, Valid)
+
+__version__ = "0.1.0"
+
+
+def enable(mode="load", policy="resolve"):
+    """Turn entail on in this process, and in any process it starts from now on.
+
+    Sets ENTAIL / ENTAIL_POLICY (children inherit the environment), sets the mode and policy here, and installs the
+    adapters: at once for engines already imported, and as each one finishes importing otherwise."""
+    os.environ["ENTAIL"] = mode
+    os.environ["ENTAIL_POLICY"] = policy
+    set_mode(mode)
+    set_policy(policy)
+    from .adapters.autoinstall import sitecustomize as _hook
+
+    _hook.activate()
+
+
+__all__ = ["RoleError", "boundary", "check_config_keys", "check_props", "check_tied", "enable", "facts_of", "mode",
+           "policy", "require", "set_mode", "set_policy", "tag", "LAYOUT_KINDS", "KernelCaps", "Layout", "ModelProps",
+           "Positions", "Quantized", "Reduction", "Valid", "__version__"]

entail_ai-0.1.0/entail/__main__.py

@@ -0,0 +1,5 @@
+import sys
+
+from .cli import main
+
+sys.exit(main())

entail_ai-0.1.0/entail/adapters/_shared.py

@@ -0,0 +1,88 @@
+"""What every engine adapter needs: read the declared properties off a config, and judge one backend.
+
+Two outcomes, and they are not the same thing:
+  violation - the table says this backend drops a property the model declares. Always an error.
+  uncovered - the table does not know this backend, so nothing was checked. An error in `debug` mode, a printed
+              warning in `load` mode, because a research table will always lag behind new backends.
+"""
+from ..facts import ModelProps
+from ..preflight import CAPS, check
+
+
+def props_of(config):
+    """ModelProps from a HF config object (PretrainedConfig or anything with the same attributes)."""
+    text = getattr(config, "text_config", None) or config
+    return ModelProps(softcap=getattr(text, "attn_logit_softcapping", None),
+                      sliding_window=getattr(text, "sliding_window", None))
+
+
+def verdict(config, backend, engine):
+    """Return (kind, message) for this config and backend, or None when there is nothing to say."""
+    props = props_of(config)
+    declared = [f"{k}={v}" for k, v in vars(props).items() if v is not None]
+    if not declared:
+        return None
+    table = CAPS[engine]
+    entry = table.get(backend) if isinstance(backend, str) else None
+    if entry is None:
+        return ("uncovered",
+                f"{engine} attention backend '{backend}' is not in the capability table, so "
+                f"{', '.join(declared)} was not checked\n  known: {', '.join(sorted(table))}")
+    missing = check(props, entry[0])
+    if not missing:
+        return None
+    return ("violation",
+            f"{engine} attention backend '{backend}' does not honour: {', '.join(missing)}"
+            f"\n  evidence: {entry[1]}")
+
+
+RESOLUTIONS = []  # every resolution made in this process, so a caller or a test can see what was changed
+
+
+def choose(config, engine, preference):
+    """The first backend in `preference` that honours everything this model declares.
+
+    Only capabilities marked as measured count: a resolution routes the value to a consumer we have *seen*
+    honour the declaration, never to one we only believe does (the table has been wrong from code reading
+    before - vLLM FLEX_ATTENTION, sweep/RESULTS.md).
+    """
+    props = props_of(config)
+    table = CAPS[engine]
+    for name in preference:
+        entry = table.get(name)
+        if entry is None or check(props, entry[0]) or "measured:" not in entry[1]:
+            continue
+        return name
+    return None
+
+
+def note_resolution(engine, where, frm, to, config):
+    """Say what was changed and why. A resolution that nobody hears about is the silent behaviour this
+    library exists to remove, so this always prints, whatever the verbosity."""
+    missing = check(props_of(config), CAPS[engine][frm][0]) if frm in CAPS[engine] else ["(not in the table)"]
+    evidence = CAPS[engine][to][1]
+    RESOLUTIONS.append({"engine": engine, "where": where, "from": frm, "to": to, "missing": missing})
+    print(f"[entail] resolved {where}: {engine} backend '{frm}' does not honour {', '.join(missing)}; "
+          f"using '{to}' instead (evidence: {evidence})", flush=True)
+
+
+def note(record, message):
+    """A resolution that is not a backend switch (a value converted to the form its consumer reads). Recorded
+    and always printed, for the same reason as note_resolution."""
+    RESOLUTIONS.append(record)
+    print(f"[entail] resolved {message}", flush=True)
+
+
+def report(said, where=""):
+    """Raise or warn according to the mode. Returns True when it warned."""
+    from .. import core
+
+    if said is None:
+        return False
+    kind, msg = said
+    if where:
+        msg = f"{where}: {msg}"
+    if kind == "violation" or core.mode() == "debug":
+        raise core.RoleError(msg)
+    print(f"[entail] {msg}", flush=True)
+    return True

entail_ai-0.1.0/entail/adapters/autoinstall/__init__.py

@@ -0,0 +1,2 @@
+"""The start-up hook lives in sitecustomize.py (see its docstring). This file makes the directory a package so the
+wheel ships the hook; putting the directory itself on PYTHONPATH still works for a source checkout."""