fluent-checks 0.1.0__py3-none-any.whl

fluent_checks/__init__.py

@@ -0,0 +1,264 @@
+from abc import ABC, abstractmethod
+from itertools import repeat
+from threading import Event, Thread
+import time
+from typing import Callable, Optional, Self, final, override
+
+type Condition = Callable[[], bool]
+
+
+class Check(ABC):
+    def __init__(self, condition: Condition) -> None:
+        super().__init__()
+        self._condition: Condition = condition
+
+    @final
+    def as_bool(self) -> bool:
+        return bool(self)
+
+    def with_delay(self, delay: float) -> "DelayedCheck":
+        return DelayedCheck(self, delay)
+
+    def succeeds_within(self, times: int) -> "RepeatingOrCheck":
+        return RepeatingOrCheck(self, times)
+
+    def is_consistent_for(self, times: int) -> "RepeatingAndCheck":
+        return RepeatingAndCheck(self, times)
+
+    def sometimes(self) -> "LoopingOrCheck":
+        return LoopingOrCheck(self)
+
+    def always(self) -> "LoopingAndCheck":
+        return LoopingAndCheck(self)
+
+    def as_waiting(self) -> "WaitingCheck":
+        return WaitingCheck(self)
+
+    def wait_for(self):
+        return self.as_waiting().wait()
+
+    def with_deadline(self, deadline: float) -> "DeadlineCheck":
+        return DeadlineCheck(self, deadline)
+
+    def with_timeout(self, timeout: float) -> "TimeoutCheck":
+        return TimeoutCheck(self, timeout)
+
+    def raises(self, exception: type[Exception]) -> "RaisesCheck":
+        return RaisesCheck(self, exception)
+
+    def __and__(self, other: Self) -> "Check":
+        return AndCheck(self, other)
+
+    def __or__(self, other: Self) -> "Check":
+        return OrCheck(self, other)
+
+    def __invert__(self) -> "Check":
+        return InvertedCheck(self)
+
+    def __bool__(self) -> bool:
+        return self._condition()
+
+    def __repr__(self) -> str:
+        try:
+            result = self.as_bool()
+        except Exception:
+            result = "<error>"
+        return f"Check({result})"
+
+
+class AllCheck(Check):
+    def __init__(self, *checks: Check) -> None:
+        super().__init__(condition=lambda: all(checks))
+        self._checks: tuple[Check, ...] = checks
+
+    def __repr__(self) -> str:
+        return " and ".join([check.__repr__() for check in self._checks])
+
+
+class AnyCheck(Check):
+    def __init__(self, *checks: Check) -> None:
+        super().__init__(condition=lambda: any(checks))
+        self._checks: tuple[Check, ...] = checks
+
+    def __repr__(self) -> str:
+        return " or ".join([check.__repr__() for check in self._checks])
+
+
+class AndCheck(AllCheck):
+    def __init__(self, left: Check, right: Check) -> None:
+        super().__init__(*[left, right])
+        self._left: Check = left
+        self._right: Check = right
+
+    def __repr__(self) -> str:
+        return f"{self._left.__repr__()} and {self._right.__repr__()}"
+
+
+class OrCheck(AnyCheck):
+    def __init__(self, left: Check, right: Check) -> None:
+        super().__init__(*[left, right])
+        self._left: Check = left
+        self._right: Check = right
+
+    def __repr__(self) -> str:
+        return f"{self._left.__repr__()} or {self._right.__repr__()}"
+
+
+class InvertedCheck(Check):
+    def __init__(self, check: Check) -> None:
+        super().__init__(condition=lambda: not check)
+        self._inverted: Check = check
+
+    def __repr__(self) -> str:
+        return f"not {self._inverted.__repr__()}"
+
+
+class DelayedCheck(Check):
+    def __init__(self, check: Check, delay: float) -> None:
+        super().__init__(condition=lambda: bool(check))
+        self._check: Check = check
+        self._delay: float = delay
+
+    @override
+    def __bool__(self) -> bool:
+        time.sleep(self._delay)
+        return self._condition()
+
+    def __repr__(self) -> str:
+        return f"DelayedCheck({self._check.__repr__()}, {self._delay})"
+
+
+class RepeatingAndCheck(AllCheck):
+    def __init__(self, check: Check, times: int) -> None:
+        super().__init__(*repeat[Check](check, times))
+        self._check: Check = check
+        self._times: int = times
+
+    def __repr__(self) -> str:
+        return f"RepeatingAndCheck({self._check.__repr__()}, {self._times})"
+
+
+class RepeatingOrCheck(AnyCheck):
+    def __init__(self, check: Check, times: int) -> None:
+        super().__init__(*repeat[Check](check, times))
+        self._check: Check = check
+        self._times: int = times
+
+    def __repr__(self) -> str:
+        return f"RepeatingOrCheck({self._check.__repr__()}, {self._times})"
+
+
+class LoopingCheck(Check):
+    def __init__(self, check: Check, initial_result: bool) -> None:
+        super().__init__(lambda: bool(check))
+        self._check: Check = check
+        self._result = initial_result
+        self._stop_event = Event()
+        self._thread: Optional[Thread] = None
+
+    @abstractmethod
+    def _loop(self) -> None:
+        pass
+
+    def __enter__(self) -> Self:
+        if self._thread is None:
+            self._thread = Thread(target=self._loop)
+            self._thread.start()
+        return self
+
+    def __exit__(self, type, value, traceback) -> None:
+        if self._thread is not None and self._thread.is_alive():
+            self._stop_event.set()
+            self._thread.join()
+            self._thread = None
+
+    @override
+    def __bool__(self) -> bool:
+        return self._result
+
+    def __repr__(self) -> str:
+        return f"LoopingCheck({self._check.__repr__()})"
+
+
+class LoopingAndCheck(LoopingCheck):
+    def __init__(self, check: Check) -> None:
+        super().__init__(check, initial_result=True)
+
+    @override
+    def _loop(self) -> None:
+        while not self._stop_event.is_set():
+            if not self._check.as_bool():
+                self._result = False
+            time.sleep(0.01)
+
+    def __repr__(self) -> str:
+        return f"LoopingAndCheck({self._check.__repr__()})"
+
+
+class LoopingOrCheck(LoopingCheck):
+    def __init__(self, check: Check) -> None:
+        super().__init__(check, initial_result=False)
+
+    @override
+    def _loop(self) -> None:
+        while not self._stop_event.is_set():
+            if self._check.as_bool():
+                self._result = True
+            time.sleep(0.01)
+
+    def __repr__(self) -> str:
+        return f"LoopingOrCheck({self._check.__repr__()})"
+
+
+class WaitingCheck(Check):
+    def __init__(self, check: Check) -> None:
+        super().__init__(lambda: bool(check))
+        self._check: Check = check
+
+    @override
+    def __bool__(self) -> bool:
+        while not self._check:
+            continue
+        return True
+
+    def wait(self) -> None:
+        bool(self)
+
+    def __repr__(self) -> str:
+        return f"WatingCheck({self._check.__repr__()})"
+
+
+class DeadlineCheck(Check):
+    def __init__(self, check: Check, deadline: float) -> None:
+        super().__init__(lambda: bool(check) if time.time() < deadline else False)
+        self._check: Check = check
+        self._deadline: float = deadline
+
+    def __repr__(self) -> str:
+        return f"DeadlineCheck({self._check.__repr__()}, {self._deadline})"
+
+
+class TimeoutCheck(DeadlineCheck):
+    def __init__(self, check: Check, timeout: float) -> None:
+        super().__init__(check, time.time() + timeout)
+        self._timeout: float = timeout
+
+    def __repr__(self) -> str:
+        return f"TimeoutCheck({self._check.__repr__()}, {self._timeout})"
+
+
+class RaisesCheck(Check):
+    def __init__(self, check: Check, exception: type[Exception]) -> None:
+        super().__init__(condition=lambda: bool(check))
+        self._check: Check = check
+        self._exception: type[Exception] = exception
+
+    def __bool__(self) -> bool:
+        try:
+            self._condition()
+            return False
+        except self._exception:
+            return True
+
+    def __repr__(self) -> str:
+        return f"RaisesCheck({self._check.__repr__()}, {self._exception.__name__})"

fluent_checks-0.1.0.dist-info/METADATA

@@ -0,0 +1,21 @@
+Metadata-Version: 2.3
+Name: fluent-checks
+Version: 0.1.0
+Summary: A library for creating fluent, readable, and composable checks for your tests or application logic.
+Keywords: fluent,checks,testing,assertions,validation
+Author: vantorrewannes
+Author-email: vantorrewannes <vantorrewannes@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Utilities
+Requires-Python: >=3.12
+Project-URL: Bug Tracker, https://github.com/VantorreWannes/fluent-checks/issues
+Project-URL: Homepage, https://github.com/VantorreWannes/fluent-checks
+Description-Content-Type: text/markdown
+
+# fluent-checks
+A simple, lightweight library for creating fluent, readable, and chainable checks in Python.

fluent_checks-0.1.0.dist-info/RECORD

@@ -0,0 +1,5 @@
+fluent_checks/__init__.py,sha256=PASUV-AhQlKCxoINTREjcmJhhViBUqim3OM6HOMqoTg,7720
+fluent_checks/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fluent_checks-0.1.0.dist-info/WHEEL,sha256=4n27za1eEkOnA7dNjN6C5-O2rUiw6iapszm14Uj-Qmk,79
+fluent_checks-0.1.0.dist-info/METADATA,sha256=_8MUtV5lmMr7iSVzhKe-CEei31zUW6pLw22LGIOiUH8,943
+fluent_checks-0.1.0.dist-info/RECORD,,

fluent_checks-0.1.0.dist-info/WHEEL

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