requiresthat 2025.6.15.6__py3-none-any.whl

requiresthat/__init__.py

@@ -0,0 +1 @@
+from ._requires import requires, RequirementNotFulfilledError, APRIORI, POSTMORTEM, BEFOREANDAFTER

requiresthat/_exceptions.py

@@ -0,0 +1,15 @@
+"""Raise this when a requirement is found wanting"""
+
+import textwrap
+
+class RequirementNotFulfilledError(Exception):
+
+    def __init__(self, that, when, msg=None):
+        """Show a default or a user-provided message indicating that some condition is unmet"""
+
+        self.default_msg = textwrap.dedent(f"""
+            {that!r} ({when.name!r}) does not hold
+        """).strip()
+
+        # Call the base class' constructor to init the exception class
+        super().__init__(msg or self.default_msg)

requiresthat/_requires.py

@@ -0,0 +1,40 @@
+"""See the README file"""
+
+from typing import Optional, Callable
+from functools import wraps
+
+from ._when import When, APRIORI, POSTMORTEM, BEFOREANDAFTER
+from ._exceptions import RequirementNotFulfilledError
+
+def requires(that, when: When = APRIORI) -> Optional[Callable]:
+    """Require <that> of the decoratee, and require it <when>"""
+
+    def func_wrapper(func: Callable) -> Optional[Callable]:
+        """First-level wrap the decoratee"""
+
+        @wraps(func)
+        def inner_wrapper(self, *pargs, **kwargs) -> Optional[Callable]:
+            """Wrap the first-level wrapper
+
+            The wrapping stops here...
+            """
+            try:
+                if when == APRIORI:
+                    assert eval(that)
+                    # We can use a return here :-)
+                    return func(self, *pargs, **kwargs)
+                elif when == POSTMORTEM:
+                    func(self, *pargs, **kwargs)
+                    assert eval(that)
+                elif when == BEFOREANDAFTER:
+                    assert eval(that)
+                    func(self, *pargs, **kwargs)
+                    assert eval(that)
+                # We don't need an else clause; trying to enlist something that's not in the enum
+                # will be penalised with an AttributeError, and small typos will be healed with a
+                # suggestion as to what you might have meant.
+            except AssertionError as exc:
+                raise RequirementNotFulfilledError(that, when) from exc
+        return inner_wrapper
+
+    return func_wrapper

requiresthat/_when.py

@@ -0,0 +1,13 @@
+"""When should a condition hold"""
+
+from enum import Enum, auto
+
+class When(Enum):
+    APRIORI = auto()
+    POSTMORTEM = auto()
+    BEFOREANDAFTER = auto()
+    # There is no DURING or INBETWEEN!
+
+APRIORI = When.APRIORI
+POSTMORTEM = When.POSTMORTEM
+BEFOREANDAFTER = When.BEFOREANDAFTER

requiresthat-2025.6.15.6.dist-info/METADATA

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: requiresthat
+Version: 2025.6.15.6
+Summary: Decorate an instance method with pre- and/or postconditions that must be fulfilled
+Author-email: Ann T Ropea <bedhanger@gmx.de>
+Project-URL: Homepage, https://gitlab.com/bedhanger/mwe/-/tree/master/python/requiresthat
+Description-Content-Type: text/x-rst
+
+requiresthat
+============
+
+Decorate an instance method with pre- and/or postconditions that must be fulfilled
+
+Example usage
+-------------
+
+.. code-block:: python
+
+    from requiresthat import requires, RequirementNotFulfilledError, APRIORI, POSTMORTEM, BEFOREANDAFTER
+
+    class C:
+
+        def __init__(self, data=None):
+            self.data = data
+
+        @requires(that='self.data is not None')
+        @requires(that='self.data == "spam"', when=APRIORI)
+        @requires(that='True is not False')
+        @requires(that='self.data != "spam"', when=POSTMORTEM)
+        @requires(that='len(self.data) >= 3', when=BEFOREANDAFTER)
+        def method(self):
+            self.data = 'ham'
+
+    X = C(data='spam')
+    X.method()
+
+The ``that`` can be almost any valid Python statement which can be evaluated for its veracity, and
+whose result will decide whether or not the method fires/will be considered a success.
+
+The parameter ``when`` decides if the condition is a-priori, post-mortem, or before-and-after.
+The default is a-priori, meaning a precondition.  Note that before-and-after does *not* mean during;
+you cannot mandate an invariant this way!
+
+``RequirementNotFulfilledError`` is the exception you have to deal with in case a condition is not
+met.

requiresthat-2025.6.15.6.dist-info/RECORD

@@ -0,0 +1,8 @@
+requiresthat/__init__.py,sha256=-pvz61UhmWhwzjbKTHQ83_YqZx1MXQEvqSgb7Q0d9jE,99
+requiresthat/_exceptions.py,sha256=bgrTgn3JCJv_KbYIpaghZ8v-SP5fiOpzeFC5zB8uq8M,504
+requiresthat/_requires.py,sha256=F28tp_3L_E06ERsSGkPx-YrbBolmGO1NymJZINtocts,1562
+requiresthat/_when.py,sha256=yQWG7qGzv0iEsLA7y0vMkbpHi4Jsby8huOzea2BG_c8,285
+requiresthat-2025.6.15.6.dist-info/METADATA,sha256=k75QG862vBm3chzLGPXdGi2X029YxF406N7GNyJoQaQ,1588
+requiresthat-2025.6.15.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+requiresthat-2025.6.15.6.dist-info/top_level.txt,sha256=mUgMTpAG75GYtt5_rVajUyWp-O_1VrrkqRo_hY9L9So,13
+requiresthat-2025.6.15.6.dist-info/RECORD,,

requiresthat-2025.6.15.6.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

requiresthat-2025.6.15.6.dist-info/top_level.txt

@@ -0,0 +1 @@
+requiresthat