pytest-imply 0.1.0__tar.gz

pytest_imply-0.1.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+*.egg
+.pytest_cache/

pytest_imply-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dimitri Staessens <dimitri@ouroboros.rocks>
+
+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.

pytest_imply-0.1.0/MANIFEST.in

@@ -0,0 +1,3 @@
+include LICENSE README.md
+recursive-include tests *.py
+recursive-include src *.py

pytest_imply-0.1.0/PKG-INFO

@@ -0,0 +1,223 @@
+Metadata-Version: 2.4
+Name: pytest-imply
+Version: 0.1.0
+Summary: Pytest plugin for test implication — skip tests implied by stronger ones
+Author-email: Dimitri Staessens <dimitri@ouroboros.rocks>
+License-Expression: MIT
+Project-URL: Homepage, https://codeberg.org/o7s/pytest-imply
+Project-URL: Repository, https://codeberg.org/o7s/pytest-imply
+Project-URL: Issues, https://codeberg.org/o7s/pytest-imply/issues
+Keywords: pytest,testing,implication,monotonic,optimization
+Classifier: Development Status :: 4 - Beta
+Classifier: Framework :: Pytest
+Classifier: Intended Audience :: Developers
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+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: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pytest>=7.0
+Dynamic: license-file
+
+# pytest-imply
+
+A pytest plugin for **test implication** — skip tests that are implied
+by stronger ones.
+
+## The problem
+
+Parametrized test suites often have an ordered severity axis:
+
+```
+test_count[c100]   PASSED   2.58s
+test_count[c500]   PASSED   4.62s
+test_count[c1000]  PASSED   7.13s
+test_count[c5000]  PASSED  27.45s
+test_count[c10000] PASSED  52.90s
+```
+
+If `c10000` passes, the smaller counts will almost certainly pass
+too — running them all wastes CI time.
+
+## The solution
+
+**pytest-imply** lets the developer declare implication relationships
+between tests.  When a stronger test passes, weaker tests are
+short-circuited with a synthetic PASSED result:
+
+```
+test_count[c10000] PASSED  52.90s
+test_count[c5000]  IMPLIED (higher count passed)
+test_count[c1000]  IMPLIED (higher count passed)
+test_count[c500]   IMPLIED (higher count passed)
+test_count[c100]   IMPLIED (higher count passed)
+```
+
+If the strongest test fails, the plugin works downward to find the
+threshold — no time wasted on tests below the passing level.
+
+## Installation
+
+```
+pip install pytest-imply
+```
+
+## Markers
+
+### `monotonic` — parametrized implication
+
+For tests parametrized along an ordered axis:
+
+```python
+@pytest.mark.monotonic("count")
+@pytest.mark.parametrize("count", [100, 500, 1000, 5000, 10000])
+def test_stress(count):
+    run_workload(count)
+```
+
+The highest value runs first.  If it passes, all lower values are
+implied.  If it fails, the next-highest runs, and so on.
+
+Use `direction="asc"` to run the smallest first:
+
+```python
+@pytest.mark.monotonic("threshold", direction="asc")
+@pytest.mark.parametrize("threshold", [0.01, 0.1, 0.5, 1.0])
+def test_precision(threshold):
+    assert error < threshold
+```
+
+### `implies` / `implied_by` / `implied_by_any` / `implied_by_all` — named tokens
+
+For arbitrary implication relationships between tests:
+
+```python
+@pytest.mark.implies("full_stack_ok")
+def test_integration():
+    """Full stack test — if this passes, unit tests are implied."""
+    ...
+
+@pytest.mark.implied_by("full_stack_ok")
+def test_unit():
+    """Implied by passing integration test — no need to run."""
+    ...
+```
+
+Use `implied_by_any` for OR semantics (implied if **any** token was
+recorded):
+
+```python
+@pytest.mark.implied_by_any("tcp_ok", "udp_ok")
+def test_loopback():
+    """Implied if either transport passed."""
+    ...
+```
+
+Use `implied_by_all` for AND semantics (implied only if **all** tokens
+were recorded):
+
+```python
+@pytest.mark.implied_by_all("tcp_ok", "udp_ok")
+def test_both_transports():
+    """Implied only if both transports passed."""
+    ...
+```
+
+## Ordering
+
+The plugin builds a dependency graph from all implication
+relationships and topologically sorts the test items using Kahn's
+algorithm.  This guarantees that implying tests always run before
+their implied dependents.  Tests without implication markers keep
+their original collection order.
+
+## Caveats
+
+- **Transitive propagation**: when a test is implied (short-circuited),
+  its `implies` tokens are still propagated, so downstream tests see
+  them.  This means chains like A→B→C work as expected.
+
+- **Stacked markers**: multiple markers of the same type on one test
+  are all honoured.  For example, stacking two `@pytest.mark.implies`
+  decorators records both sets of tokens.
+
+- **Token namespacing**: tokens live in a single flat namespace.
+  In large projects, use a prefix convention (e.g.,
+  `"mymodule::token"`) to avoid accidental collisions between
+  independently-authored test modules.
+
+- **Fixtures**: when a test is implied, its fixtures **do not run**.
+  If an implied test has a session- or module-scoped fixture whose
+  side effects other tests depend on, those tests may break.  Only
+  mark tests as implied when their fixtures are not needed by other
+  tests.
+
+- **pytest-xdist**: the plugin does not support parallel workers.
+  Implication state is per-process.  When xdist is active with
+  workers, implication logic is **automatically disabled** and a
+  warning is emitted.  Use `-p no:imply` to suppress the warning.
+
+- **Plugin interoperability**: when a test is implied, the plugin
+  returns `True` from `pytest_runtest_protocol`, which tells pytest
+  the item is fully handled.  Other plugins that wrap the test
+  protocol (e.g., `pytest-cov`, `pytest-timeout`) will not see
+  implied tests.  This is inherent to the short-circuit design.
+
+- **Orphan tokens**: if an `implied_by` (or variant) references a
+  token that no test provides via `implies`, a warning is emitted
+  at collection time.
+
+- **Dependency cycles**: if implication markers form a cycle, the
+  plugin falls back to original collection order for the affected
+  tests and emits a warning.
+
+- **xfail interaction**: a test marked `@pytest.mark.xfail` with
+  `strict=False` that passes (xpass) **does** record its `implies`
+  tokens.  With `strict=True`, an xpass is treated as a failure and
+  tokens are **not** recorded.
+
+## Disabling implication
+
+### `--no-imply`
+
+Disable all implication logic and run every test:
+
+```
+pytest --no-imply
+```
+
+Use this for exhaustive nightly or release-gate runs to verify that
+the developer's implication assumptions still hold.
+
+### `imply_enabled` ini option
+
+Disable implication via configuration instead of a CLI flag:
+
+```toml
+[tool.pytest.ini_options]
+imply_enabled = false
+```
+
+## How it works
+
+1. **Collection** — `pytest_collection_modifyitems` builds the
+   dependency graph and topologically sorts items.
+2. **Execution** — `pytest_runtest_protocol` checks whether a test is
+   implied; if so, it emits synthetic `TestReport` objects and
+   returns `True`.
+3. **Recording** — `pytest_runtest_makereport` records tokens and
+   monotonic passes after a test succeeds.
+4. **Reporting** — `pytest_report_teststatus` renders implied tests as
+   `IMPLIED (reason)` with a cyan `i` marker.
+
+## License
+
+MIT

pytest_imply-0.1.0/README.md

@@ -0,0 +1,194 @@
+# pytest-imply
+
+A pytest plugin for **test implication** — skip tests that are implied
+by stronger ones.
+
+## The problem
+
+Parametrized test suites often have an ordered severity axis:
+
+```
+test_count[c100]   PASSED   2.58s
+test_count[c500]   PASSED   4.62s
+test_count[c1000]  PASSED   7.13s
+test_count[c5000]  PASSED  27.45s
+test_count[c10000] PASSED  52.90s
+```
+
+If `c10000` passes, the smaller counts will almost certainly pass
+too — running them all wastes CI time.
+
+## The solution
+
+**pytest-imply** lets the developer declare implication relationships
+between tests.  When a stronger test passes, weaker tests are
+short-circuited with a synthetic PASSED result:
+
+```
+test_count[c10000] PASSED  52.90s
+test_count[c5000]  IMPLIED (higher count passed)
+test_count[c1000]  IMPLIED (higher count passed)
+test_count[c500]   IMPLIED (higher count passed)
+test_count[c100]   IMPLIED (higher count passed)
+```
+
+If the strongest test fails, the plugin works downward to find the
+threshold — no time wasted on tests below the passing level.
+
+## Installation
+
+```
+pip install pytest-imply
+```
+
+## Markers
+
+### `monotonic` — parametrized implication
+
+For tests parametrized along an ordered axis:
+
+```python
+@pytest.mark.monotonic("count")
+@pytest.mark.parametrize("count", [100, 500, 1000, 5000, 10000])
+def test_stress(count):
+    run_workload(count)
+```
+
+The highest value runs first.  If it passes, all lower values are
+implied.  If it fails, the next-highest runs, and so on.
+
+Use `direction="asc"` to run the smallest first:
+
+```python
+@pytest.mark.monotonic("threshold", direction="asc")
+@pytest.mark.parametrize("threshold", [0.01, 0.1, 0.5, 1.0])
+def test_precision(threshold):
+    assert error < threshold
+```
+
+### `implies` / `implied_by` / `implied_by_any` / `implied_by_all` — named tokens
+
+For arbitrary implication relationships between tests:
+
+```python
+@pytest.mark.implies("full_stack_ok")
+def test_integration():
+    """Full stack test — if this passes, unit tests are implied."""
+    ...
+
+@pytest.mark.implied_by("full_stack_ok")
+def test_unit():
+    """Implied by passing integration test — no need to run."""
+    ...
+```
+
+Use `implied_by_any` for OR semantics (implied if **any** token was
+recorded):
+
+```python
+@pytest.mark.implied_by_any("tcp_ok", "udp_ok")
+def test_loopback():
+    """Implied if either transport passed."""
+    ...
+```
+
+Use `implied_by_all` for AND semantics (implied only if **all** tokens
+were recorded):
+
+```python
+@pytest.mark.implied_by_all("tcp_ok", "udp_ok")
+def test_both_transports():
+    """Implied only if both transports passed."""
+    ...
+```
+
+## Ordering
+
+The plugin builds a dependency graph from all implication
+relationships and topologically sorts the test items using Kahn's
+algorithm.  This guarantees that implying tests always run before
+their implied dependents.  Tests without implication markers keep
+their original collection order.
+
+## Caveats
+
+- **Transitive propagation**: when a test is implied (short-circuited),
+  its `implies` tokens are still propagated, so downstream tests see
+  them.  This means chains like A→B→C work as expected.
+
+- **Stacked markers**: multiple markers of the same type on one test
+  are all honoured.  For example, stacking two `@pytest.mark.implies`
+  decorators records both sets of tokens.
+
+- **Token namespacing**: tokens live in a single flat namespace.
+  In large projects, use a prefix convention (e.g.,
+  `"mymodule::token"`) to avoid accidental collisions between
+  independently-authored test modules.
+
+- **Fixtures**: when a test is implied, its fixtures **do not run**.
+  If an implied test has a session- or module-scoped fixture whose
+  side effects other tests depend on, those tests may break.  Only
+  mark tests as implied when their fixtures are not needed by other
+  tests.
+
+- **pytest-xdist**: the plugin does not support parallel workers.
+  Implication state is per-process.  When xdist is active with
+  workers, implication logic is **automatically disabled** and a
+  warning is emitted.  Use `-p no:imply` to suppress the warning.
+
+- **Plugin interoperability**: when a test is implied, the plugin
+  returns `True` from `pytest_runtest_protocol`, which tells pytest
+  the item is fully handled.  Other plugins that wrap the test
+  protocol (e.g., `pytest-cov`, `pytest-timeout`) will not see
+  implied tests.  This is inherent to the short-circuit design.
+
+- **Orphan tokens**: if an `implied_by` (or variant) references a
+  token that no test provides via `implies`, a warning is emitted
+  at collection time.
+
+- **Dependency cycles**: if implication markers form a cycle, the
+  plugin falls back to original collection order for the affected
+  tests and emits a warning.
+
+- **xfail interaction**: a test marked `@pytest.mark.xfail` with
+  `strict=False` that passes (xpass) **does** record its `implies`
+  tokens.  With `strict=True`, an xpass is treated as a failure and
+  tokens are **not** recorded.
+
+## Disabling implication
+
+### `--no-imply`
+
+Disable all implication logic and run every test:
+
+```
+pytest --no-imply
+```
+
+Use this for exhaustive nightly or release-gate runs to verify that
+the developer's implication assumptions still hold.
+
+### `imply_enabled` ini option
+
+Disable implication via configuration instead of a CLI flag:
+
+```toml
+[tool.pytest.ini_options]
+imply_enabled = false
+```
+
+## How it works
+
+1. **Collection** — `pytest_collection_modifyitems` builds the
+   dependency graph and topologically sorts items.
+2. **Execution** — `pytest_runtest_protocol` checks whether a test is
+   implied; if so, it emits synthetic `TestReport` objects and
+   returns `True`.
+3. **Recording** — `pytest_runtest_makereport` records tokens and
+   monotonic passes after a test succeeds.
+4. **Reporting** — `pytest_report_teststatus` renders implied tests as
+   `IMPLIED (reason)` with a cyan `i` marker.
+
+## License
+
+MIT

pytest_imply-0.1.0/pyproject.toml

@@ -0,0 +1,47 @@
+[project]
+name = "pytest-imply"
+dynamic = ["version"]
+description = "Pytest plugin for test implication — skip tests implied by stronger ones"
+readme = "README.md"
+license = "MIT"
+authors = [
+    { name = "Dimitri Staessens", email = "dimitri@ouroboros.rocks" },
+]
+requires-python = ">=3.8"
+dependencies = ["pytest>=7.0"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Framework :: Pytest",
+    "Intended Audience :: Developers",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Topic :: Software Development :: Testing",
+]
+keywords = ["pytest", "testing", "implication", "monotonic", "optimization"]
+
+[project.urls]
+Homepage = "https://codeberg.org/o7s/pytest-imply"
+Repository = "https://codeberg.org/o7s/pytest-imply"
+Issues = "https://codeberg.org/o7s/pytest-imply/issues"
+
+[project.entry-points.pytest11]
+imply = "pytest_imply.plugin"
+
+[build-system]
+requires = ["setuptools>=64", "setuptools-scm>=8"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools_scm]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

pytest_imply-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pytest_imply-0.1.0/src/pytest_imply/__init__.py

@@ -0,0 +1,12 @@
+"""pytest-imply — skip tests implied by stronger ones."""
+
+from importlib.metadata import version, PackageNotFoundError
+
+from pytest_imply.plugin import PytestImplyWarning
+
+try:
+    __version__ = version("pytest-imply")
+except PackageNotFoundError:
+    __version__ = "unknown"
+
+__all__ = ["PytestImplyWarning", "__version__"]