pytest-check 2.7.4__tar.gz → 2.7.6__tar.gz

{pytest_check-2.7.4 → pytest_check-2.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-check
-Version: 2.7.4
+Version: 2.7.6
 Summary: A pytest plugin that allows multiple failures per test.
 Project-URL: Home, https://github.com/okken/pytest-check
 Author: Brian Okken

{pytest_check-2.7.4 → pytest_check-2.7.6}/changelog.md

@@ -28,6 +28,21 @@ All notable changes to this project will be documented in this file.
 
 -->
 
+## [2.7.6] - 2026-Mar-04
+
+### Fixed
+
+- (typing) Set comparison function types such that None is not allowed
+
+## [2.7.5] - 2026-Mar-04
+
+### Changed
+
+- Passing `None` to comparison functions like `greater()`, `less()`, etc. used to raise an exception, which caused a test failure and stopped the test. 
+ - That's unexpected with a check function. 
+ - So now the check fails with a meaningful error message and continues with the rest of the test.
+- (typing) Allow numpy floats with comparison functions to pass mypy.
+
 ## [2.7.4] - 2026-Mar-03
 
 ### Fixed

{pytest_check-2.7.4 → pytest_check-2.7.6}/examples/test_example_mypy.py

@@ -7,16 +7,25 @@ Normally you would import the check functions like this:
 We're testing that an old form of import also works:
     import pytest_check as check
 
-However, please be aware that this method of importing is deprecated and 
+However, please be aware that this method of importing is deprecated and
 support may be removed in future versions.
 
 The original content of this file is from test_example_functions_pass.py.
-But I've also added more tests to check for anything I want to get 
+But I've also added more tests to check for anything I want to get
 tested with `mypy --strict`.
 """
 
-import pytest_check as check
 import math
+import importlib
+from typing import Any
+import pytest
+import pytest_check as check
+
+try:
+    np: Any = importlib.import_module("numpy")
+except ModuleNotFoundError:
+    np = None
+
 
 def test_equal() -> None:
     check.equal(1, 1)
@@ -100,11 +109,13 @@ def test_greater_equal() -> None:
     check.greater_equal(2, 1)
     check.greater_equal(1, 1)
 
-def test_greater_equal_int_float() -> None:
+
+def test_int_float() -> None:
     check.greater(2, 1.9)
     check.greater_equal(2, 1.9)
     check.less(1.9, 2)
     check.less_equal(1.9, 2)
+    check.between(10, 4.5, 20)
 
 
 def test_less() -> None:
@@ -140,3 +151,34 @@ def test_between_equal() -> None:
     check.between_equal(0, 0, 20)
     check.between_equal(10, 0, 20)
     check.between_equal(20, 0, 20)
+
+
+@pytest.mark.skipif(np is None, reason="numpy is not installed")
+def test_greater_equal_max_int() -> None:
+    if np is not None:
+        check.greater_equal(np.iinfo(np.int32).max, 0)
+
+
+@pytest.mark.skipif(np is None, reason="numpy is not installed")
+def test_greater_equal_max_float() -> None:
+    if np is not None:
+        check.greater_equal(np.finfo(np.float32).max, 0)
+
+
+@pytest.mark.skipif(np is None, reason="numpy is not installed")
+def test_greater_max_int() -> None:
+    if np is not None:
+        check.greater(np.iinfo(np.int32).max, 0)
+
+
+@pytest.mark.skipif(np is None, reason="numpy is not installed")
+def test_less_min_float() -> None:
+    if np is not None:
+        check.less(np.finfo(np.float32).min, 0)
+
+
+@pytest.mark.skipif(np is None, reason="numpy is not installed")
+def test_less_equal_max_float() -> None:
+    if np is not None:
+        max_f32 = np.finfo(np.float32).max
+        check.less_equal(max_f32, max_f32)

pytest_check-2.7.6/examples/test_example_mypy_fail.py

@@ -0,0 +1,27 @@
+import pytest
+from pytest_check import check
+
+
+@pytest.mark.xfail(reason="None cannot be compared")
+def test_none_less() -> None:
+    check.less(None, 1)
+
+
+@pytest.mark.xfail(reason="None cannot be compared")
+def test_none_less_equal() -> None:
+    check.less_equal(None, 1)
+
+
+@pytest.mark.xfail(reason="None cannot be compared")
+def test_none_greater() -> None:
+    check.greater(1, None)
+
+
+@pytest.mark.xfail(reason="None cannot be compared")
+def test_none_greater_equal() -> None:
+    check.greater_equal(1, None)
+
+
+@pytest.mark.xfail(reason="None cannot be compared")
+def test_none_between() -> None:
+    check.between(1, None, 2)

{pytest_check-2.7.4 → pytest_check-2.7.6}/pyproject.toml

@@ -4,7 +4,7 @@ authors = [{name = "Brian Okken"}]
 readme = "README.md"
 license = {file = "LICENSE.txt"}
 description="A pytest plugin that allows multiple failures per test."
-version = "2.7.4"
+version = "2.7.6"
 requires-python = ">=3.9"
 classifiers = [
     'Development Status :: 5 - Production/Stable',

pytest_check-2.7.6/src/pytest_check/__init__.pyi

@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+from typing import (
+    Any,
+    Callable,
+    Protocol,
+    SupportsFloat,
+    SupportsIndex,
+    TypeVar,
+    overload,
+)
+
+from .context_manager import CheckContextManager as _BaseCheck
+from .check_functions import (
+    assert_equal,
+    equal,
+    not_equal,
+    is_,
+    is_not,
+    is_true,
+    is_false,
+    is_none,
+    is_not_none,
+    is_nan,
+    is_not_nan,
+    is_in,
+    is_not_in,
+    is_instance,
+    is_not_instance,
+    almost_equal,
+    not_almost_equal,
+    greater,
+    greater_equal,
+    less,
+    less_equal,
+    between,
+    between_equal,
+    check_func,
+    fail,
+)
+from .check_raises import raises
+from .check_log import any_failures
+
+_CmpT = TypeVar("_CmpT", contravariant=True)
+
+class _ComparableGreaterThan(Protocol[_CmpT]):
+    def __gt__(self, other: _CmpT, /) -> bool: ...
+
+class _ComparableGreaterThanOrEqual(Protocol[_CmpT]):
+    def __ge__(self, other: _CmpT, /) -> bool: ...
+
+class _ComparableLessThan(Protocol[_CmpT]):
+    def __lt__(self, other: _CmpT, /) -> bool: ...
+
+class _ComparableLessThanOrEqual(Protocol[_CmpT]):
+    def __le__(self, other: _CmpT, /) -> bool: ...
+
+class CheckType(_BaseCheck):
+    # Helper functions exposed as attributes on the check object
+    assert_equal: Callable[..., None]
+    equal: Callable[..., bool]
+    not_equal: Callable[..., bool]
+    is_: Callable[..., bool]
+    is_not: Callable[..., bool]
+    is_true: Callable[..., bool]
+    is_false: Callable[..., bool]
+    is_none: Callable[..., bool]
+    is_not_none: Callable[..., bool]
+    is_nan: Callable[..., bool]
+    is_not_nan: Callable[..., bool]
+    is_in: Callable[..., bool]
+    is_not_in: Callable[..., bool]
+    is_instance: Callable[..., bool]
+    is_not_instance: Callable[..., bool]
+    almost_equal: Callable[..., bool]
+    not_almost_equal: Callable[..., bool]
+    @overload
+    def greater(self, a: float, b: float, msg: str = "") -> bool: ...
+    @overload
+    def greater(
+        self,
+        a: SupportsFloat | SupportsIndex,
+        b: SupportsFloat | SupportsIndex,
+        msg: str = "",
+    ) -> bool: ...
+    @overload
+    def greater(
+        self, a: _ComparableGreaterThan[_CmpT], b: _CmpT, msg: str = ""
+    ) -> bool: ...
+    @overload
+    def greater_equal(self, a: float, b: float, msg: str = "") -> bool: ...
+    @overload
+    def greater_equal(
+        self,
+        a: SupportsFloat | SupportsIndex,
+        b: SupportsFloat | SupportsIndex,
+        msg: str = "",
+    ) -> bool: ...
+    @overload
+    def greater_equal(
+        self, a: _ComparableGreaterThanOrEqual[_CmpT], b: _CmpT, msg: str = ""
+    ) -> bool: ...
+    @overload
+    def less(self, a: float, b: float, msg: str = "") -> bool: ...
+    @overload
+    def less(
+        self,
+        a: SupportsFloat | SupportsIndex,
+        b: SupportsFloat | SupportsIndex,
+        msg: str = "",
+    ) -> bool: ...
+    @overload
+    def less(self, a: _ComparableLessThan[_CmpT], b: _CmpT, msg: str = "") -> bool: ...
+    @overload
+    def less_equal(self, a: float, b: float, msg: str = "") -> bool: ...
+    @overload
+    def less_equal(
+        self,
+        a: SupportsFloat | SupportsIndex,
+        b: SupportsFloat | SupportsIndex,
+        msg: str = "",
+    ) -> bool: ...
+    @overload
+    def less_equal(
+        self, a: _ComparableLessThanOrEqual[_CmpT], b: _CmpT, msg: str = ""
+    ) -> bool: ...
+    @overload
+    def between(
+        self,
+        b: float,
+        a: float,
+        c: float,
+        msg: str = "",
+        ge: bool = False,
+        le: bool = False,
+    ) -> bool: ...
+    @overload
+    def between(
+        self,
+        b: SupportsFloat | SupportsIndex,
+        a: SupportsFloat | SupportsIndex,
+        c: SupportsFloat | SupportsIndex,
+        msg: str = "",
+        ge: bool = False,
+        le: bool = False,
+    ) -> bool: ...
+    @overload
+    def between(
+        self,
+        b: _ComparableLessThanOrEqual[_CmpT],
+        a: _CmpT,
+        c: _CmpT,
+        msg: str = "",
+        ge: bool = False,
+        le: bool = False,
+    ) -> bool: ...
+    @overload
+    def between_equal(self, b: float, a: float, c: float, msg: str = "") -> bool: ...
+    @overload
+    def between_equal(
+        self,
+        b: SupportsFloat | SupportsIndex,
+        a: SupportsFloat | SupportsIndex,
+        c: SupportsFloat | SupportsIndex,
+        msg: str = "",
+    ) -> bool: ...
+    @overload
+    def between_equal(
+        self,
+        b: _ComparableLessThanOrEqual[_CmpT],
+        a: _CmpT,
+        c: _CmpT,
+        msg: str = "",
+    ) -> bool: ...
+    check_func: Callable[..., Callable[..., bool]]
+    fail: Callable[..., None]
+
+    # Extra helpers attached in __init__.py
+    raises: Callable[..., Any]
+    any_failures: Callable[..., bool]
+
+    # Some users do check.check, so keep it typed
+    check: "CheckType"
+
+check: CheckType
+
+__all__ = [
+    # main interface objects
+    "check",
+    "raises",
+    "any_failures",
+    # helper functions available as module attributes
+    "assert_equal",
+    "equal",
+    "not_equal",
+    "is_",
+    "is_not",
+    "is_true",
+    "is_false",
+    "is_none",
+    "is_not_none",
+    "is_nan",
+    "is_not_nan",
+    "is_in",
+    "is_not_in",
+    "is_instance",
+    "is_not_instance",
+    "almost_equal",
+    "not_almost_equal",
+    "greater",
+    "greater_equal",
+    "less",
+    "less_equal",
+    "between",
+    "between_equal",
+    "check_func",
+    "fail",
+]

{pytest_check-2.7.4 → pytest_check-2.7.6}/src/pytest_check/check_functions.py

@@ -54,7 +54,6 @@ __all__ = [
 _P = ParamSpec("_P")
 _T = TypeVar("_T")
 
-
 _CmpT = TypeVar("_CmpT", contravariant=True)
 
 
@@ -255,13 +254,22 @@ def not_almost_equal(
 def greater(a: float, b: float, msg: str = "") -> bool: ...
 
 
+@overload
+def greater(
+    a: SupportsFloat | SupportsIndex, b: SupportsFloat | SupportsIndex, msg: str = ""
+) -> bool: ...
+
+
 @overload
 def greater(a: _ComparableGreaterThan[_CmpT], b: _CmpT, msg: str = "") -> bool: ...
 
 
 def greater(a: Any, b: Any, msg: str = "") -> bool:
     __tracebackhide__ = True
-    if a > b:
+    if a is None or b is None:
+        log_failure(f"check {a} > {b}: None cannot be compared", msg)
+        return False
+    elif a > b:
         return True
     else:
         log_failure(f"check {a} > {b}", msg)
@@ -272,6 +280,12 @@ def greater(a: Any, b: Any, msg: str = "") -> bool:
 def greater_equal(a: float, b: float, msg: str = "") -> bool: ...
 
 
+@overload
+def greater_equal(
+    a: SupportsFloat | SupportsIndex, b: SupportsFloat | SupportsIndex, msg: str = ""
+) -> bool: ...
+
+
 @overload
 def greater_equal(
     a: _ComparableGreaterThanOrEqual[_CmpT], b: _CmpT, msg: str = ""
@@ -280,7 +294,10 @@ def greater_equal(
 
 def greater_equal(a: Any, b: Any, msg: str = "") -> bool:
     __tracebackhide__ = True
-    if a >= b:
+    if a is None or b is None:
+        log_failure(f"check {a} >= {b}: None cannot be compared", msg)
+        return False
+    elif a >= b:
         return True
     else:
         log_failure(f"check {a} >= {b}", msg)
@@ -291,13 +308,22 @@ def greater_equal(a: Any, b: Any, msg: str = "") -> bool:
 def less(a: float, b: float, msg: str = "") -> bool: ...
 
 
+@overload
+def less(
+    a: SupportsFloat | SupportsIndex, b: SupportsFloat | SupportsIndex, msg: str = ""
+) -> bool: ...
+
+
 @overload
 def less(a: _ComparableLessThan[_CmpT], b: _CmpT, msg: str = "") -> bool: ...
 
 
 def less(a: Any, b: Any, msg: str = "") -> bool:
     __tracebackhide__ = True
-    if a < b:
+    if a is None or b is None:
+        log_failure(f"check {a} < {b}: None cannot be compared", msg)
+        return False
+    elif a < b:
         return True
     else:
         log_failure(f"check {a} < {b}", msg)
@@ -308,6 +334,12 @@ def less(a: Any, b: Any, msg: str = "") -> bool:
 def less_equal(a: float, b: float, msg: str = "") -> bool: ...
 
 
+@overload
+def less_equal(
+    a: SupportsFloat | SupportsIndex, b: SupportsFloat | SupportsIndex, msg: str = ""
+) -> bool: ...
+
+
 @overload
 def less_equal(
     a: _ComparableLessThanOrEqual[_CmpT], b: _CmpT, msg: str = ""
@@ -316,18 +348,52 @@ def less_equal(
 
 def less_equal(a: Any, b: Any, msg: str = "") -> bool:
     __tracebackhide__ = True
-    if a <= b:
+    if a is None or b is None:
+        log_failure(f"check {a} <= {b}: None cannot be compared", msg)
+        return False
+    elif a <= b:
         return True
     else:
         log_failure(f"check {a} <= {b}", msg)
         return False
 
 
+@overload
+def between(
+    b: float, a: float, c: float, msg: str = "", ge: bool = False, le: bool = False
+) -> bool: ...
+
+
+@overload
+def between(
+    b: SupportsFloat | SupportsIndex,
+    a: SupportsFloat | SupportsIndex,
+    c: SupportsFloat | SupportsIndex,
+    msg: str = "",
+    ge: bool = False,
+    le: bool = False,
+) -> bool: ...
+
+
+@overload
+def between(
+    b: _ComparableLessThanOrEqual[_CmpT],
+    a: _CmpT,
+    c: _CmpT,
+    msg: str = "",
+    ge: bool = False,
+    le: bool = False,
+) -> bool: ...
+
+
 def between(
     b: Any, a: Any, c: Any, msg: str = "", ge: bool = False, le: bool = False
 ) -> bool:
     __tracebackhide__ = True
-    if ge and le:
+    if a is None or b is None or c is None:
+        log_failure(f"check {a} <= {b} <= {c}: None cannot be compared", msg)
+        return False
+    elif ge and le:
         if a <= b <= c:
             return True
         else:
@@ -353,11 +419,33 @@ def between(
             return False
 
 
+@overload
+def between_equal(b: float, a: float, c: float, msg: str = "") -> bool: ...
+
+
+@overload
+def between_equal(
+    b: SupportsFloat | SupportsIndex,
+    a: SupportsFloat | SupportsIndex,
+    c: SupportsFloat | SupportsIndex,
+    msg: str = "",
+) -> bool: ...
+
+
+@overload
 def between_equal(
     b: _ComparableLessThanOrEqual[_CmpT],
-    a: _ComparableLessThanOrEqual[_CmpT],
+    a: _CmpT,
     c: _CmpT,
     msg: str = "",
+) -> bool: ...
+
+
+def between_equal(
+    b: Any,
+    a: Any,
+    c: Any,
+    msg: str = "",
 ) -> bool:
     __tracebackhide__ = True
     return between(b, a, c, msg, ge=True, le=True)

{pytest_check-2.7.4 → pytest_check-2.7.6}/tests/test_xfail.py

@@ -102,3 +102,9 @@ def test_xfail_raises_multiple_marks_one_matches(pytester):
     )
     result.assert_outcomes(xfailed=1)
     result.stdout.fnmatch_lines(["* 1 xfailed *"])
+
+def test_xfail_mypy(pytester):
+    pytester.copy_example("examples/test_example_mypy_fail.py")
+    result = pytester.runpytest("test_example_mypy_fail.py")
+    result.assert_outcomes(xfailed=5)
+    result.stdout.fnmatch_lines(["* 5 xfailed *"])

{pytest_check-2.7.4 → pytest_check-2.7.6}/tox.ini

@@ -44,18 +44,22 @@ description = Run ruff over src, test, examples
 deps =
     mypy
     httpx
+    numpy
     # pluggy added type checking support in version 1.3.0
     pluggy>=1.3,<2
 base_python = python3.14
 commands =
     # want strict for src so users can use strict if they want
-    mypy --strict --pretty src
+    mypy --strict src
 
     # don't need strict for internal tests
-    mypy --pretty tests
+    mypy tests
 
-    # for one example test, try full strict
-    mypy --pretty --strict examples/test_example_mypy.py
+    # tests that support --strict
+    mypy --strict examples/test_example_mypy.py 
+
+    # considering ways to make sure this fails
+    # mypy --strict examples/test_example_mypy_fail.py
 
     # for most examples, I'd like to not use all type hints to aid in readability
     ; --strict  # mostly strict
@@ -66,7 +70,7 @@ commands =
         --allow-untyped-defs \
         --disable-error-code=comparison-overlap \
         --disable-error-code=no-untyped-call \
-        examples
+        examples --exclude examples/test_example_mypy_fail.py
 description = Run mypy over src, test, examples
 
 [pytest]

pytest_check-2.7.4/src/pytest_check/__init__.pyi

@@ -1,107 +0,0 @@
-from __future__ import annotations
-
-from typing import Any, Callable
-
-from .context_manager import CheckContextManager as _BaseCheck
-from .check_functions import (
-    assert_equal,
-    equal,
-    not_equal,
-    is_,
-    is_not,
-    is_true,
-    is_false,
-    is_none,
-    is_not_none,
-    is_nan,
-    is_not_nan,
-    is_in,
-    is_not_in,
-    is_instance,
-    is_not_instance,
-    almost_equal,
-    not_almost_equal,
-    greater,
-    greater_equal,
-    less,
-    less_equal,
-    between,
-    between_equal,
-    check_func,
-    fail,
-)
-from .check_raises import raises
-from .check_log import any_failures
-
-
-class CheckType(_BaseCheck):
-    # Helper functions exposed as attributes on the check object
-    assert_equal: Callable[..., None]
-    equal: Callable[..., bool]
-    not_equal: Callable[..., bool]
-    is_: Callable[..., bool]
-    is_not: Callable[..., bool]
-    is_true: Callable[..., bool]
-    is_false: Callable[..., bool]
-    is_none: Callable[..., bool]
-    is_not_none: Callable[..., bool]
-    is_nan: Callable[..., bool]
-    is_not_nan: Callable[..., bool]
-    is_in: Callable[..., bool]
-    is_not_in: Callable[..., bool]
-    is_instance: Callable[..., bool]
-    is_not_instance: Callable[..., bool]
-    almost_equal: Callable[..., bool]
-    not_almost_equal: Callable[..., bool]
-    greater: Callable[..., bool]
-    greater_equal: Callable[..., bool]
-    less: Callable[..., bool]
-    less_equal: Callable[..., bool]
-    between: Callable[..., bool]
-    between_equal: Callable[..., bool]
-    check_func: Callable[..., Callable[..., bool]]
-    fail: Callable[..., None]
-
-    # Extra helpers attached in __init__.py
-    raises: Callable[..., Any]
-    any_failures: Callable[..., bool]
-
-    # Some users do check.check, so keep it typed
-    check: "CheckType"
-
-
-check: CheckType
-
-__all__ = [
-    # main interface objects
-    "check",
-    "raises",
-    "any_failures",
-    # helper functions available as module attributes
-    "assert_equal",
-    "equal",
-    "not_equal",
-    "is_",
-    "is_not",
-    "is_true",
-    "is_false",
-    "is_none",
-    "is_not_none",
-    "is_nan",
-    "is_not_nan",
-    "is_in",
-    "is_not_in",
-    "is_instance",
-    "is_not_instance",
-    "almost_equal",
-    "not_almost_equal",
-    "greater",
-    "greater_equal",
-    "less",
-    "less_equal",
-    "between",
-    "between_equal",
-    "check_func",
-    "fail",
-]
-