requiresthat 2025.6.19.3__tar.gz → 2025.6.20.0__tar.gz

{requiresthat-2025.6.19.3 → requiresthat-2025.6.20.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: requiresthat
-Version: 2025.6.19.3
+Version: 2025.6.20.0
 Summary: Support for requirements-assisted development
 Author-email: Ann T Ropea <bedhanger@gmx.de>
 License-Expression: MIT

{requiresthat-2025.6.19.3 → requiresthat-2025.6.20.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "requiresthat"
-version = "2025.6.19.3"
+version = "2025.6.20.0"
 authors = [
     {name = "Ann T Ropea", email = "bedhanger@gmx.de"},
 ]

{requiresthat-2025.6.19.3 → requiresthat-2025.6.20.0}/src/requiresthat/_exceptions.py

@@ -3,7 +3,7 @@ import textwrap
 class RequirementNotFulfilledError(Exception):
     """Raise this when a requirement is found wanting"""
 
-    def __init__(self, that, when, subwhen=str(), msg=None):
+    def __init__(self, that, when, subwhen: str = str(), msg=None):
         """Show a default or a user-provided message indicating that some condition is unmet"""
 
         if subwhen:

requiresthat-2025.6.20.0/src/requiresthat/_requires.py

@@ -0,0 +1,87 @@
+"""See the `README
+<https://gitlab.com/bedhanger/mwe/-/blob/master/python/requiresthat/README.rst>`_ file
+"""
+from typing import Optional, Callable
+from functools import wraps
+
+from ._when import When, APRIORI, POSTMORTEM, BEFOREANDAFTER
+from ._exceptions import RequirementNotFulfilledError, NoCallableConstructError
+
+def requires(that, when: When = APRIORI) -> Optional[Callable]:
+    """Require ``that`` of the decoratee, and require it ``when``
+
+    Fail if the associated construct is not callable.
+
+    Fail if the condition is not met: do not invoke the callable or prevent the operation from being
+    considered a success.
+
+    Needs the callable to be an instance method of a class, like so:
+
+        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()
+
+    Try adding
+
+        the_impossible = '1 / 0'
+    and
+        @requires(the_impossible)
+
+    to the list of decorators above and watch what happens.
+    """
+    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...
+            """
+            if not callable(__func):
+                raise NoCallableConstructError(__func)
+            else:
+                if when == APRIORI:
+                    __assert(self, that, when)
+                    __func(self, *pargs, **kwargs)
+
+                elif when == POSTMORTEM:
+                    __func(self, *pargs, **kwargs)
+                    __assert(self, that, when)
+
+                elif when == BEFOREANDAFTER:
+                    __assert(self, that, when, APRIORI)
+                    __func(self, *pargs, **kwargs)
+                    __assert(self, that, when, POSTMORTEM)
+
+                # 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.
+
+        return inner_wrapper
+
+    return func_wrapper
+
+def __assert(self, that, when: When, subwhen: str = str()):
+    """Do the actual testing and raise the proper exceptions
+
+    The reason we don't use assert here is to avoid the Knuthian dilemma of premature optimisation;
+    namely, that it nukes this useful tool, :-[
+    """
+    try:
+        if not eval(that):
+            raise RequirementNotFulfilledError(that, when, subwhen) from None
+    except:
+        raise RequirementNotFulfilledError(that, when, subwhen)  from None

{requiresthat-2025.6.19.3 → requiresthat-2025.6.20.0}/src/requiresthat.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: requiresthat
-Version: 2025.6.19.3
+Version: 2025.6.20.0
 Summary: Support for requirements-assisted development
 Author-email: Ann T Ropea <bedhanger@gmx.de>
 License-Expression: MIT

{requiresthat-2025.6.19.3 → requiresthat-2025.6.20.0}/tests/test_requiresthat.py

@@ -75,14 +75,14 @@ class TestCase_requiresthat_01:
 
         class Spam:
 
-            @requires(that='self.spam == "eggs"')
+            @requires(that='self.spam == "ham"')
             def __init__(self):
                 self.spam = 'ham'
 
             def run(self): ...
 
-        # We break the constructor (the fact that we confuse spam and eggs is incidental)
-        with pytest.raises(AttributeError):
+        # We break the constructor
+        with pytest.raises(RequirementNotFulfilledError):
             S = Spam()
 
         # Remember, the constructor just failed...

requiresthat-2025.6.19.3/src/requiresthat/_requires.py

@@ -1,62 +0,0 @@
-"""See the `README
-<https://gitlab.com/bedhanger/mwe/-/blob/master/python/requiresthat/README.rst>`_ file
-"""
-from typing import Optional, Callable
-from functools import wraps
-
-from ._when import When, APRIORI, POSTMORTEM, BEFOREANDAFTER
-from ._exceptions import RequirementNotFulfilledError, NoCallableConstructError
-
-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:
-                assert callable(func)
-            except AssertionError as exc:
-                raise NoCallableConstructError(func) from exc
-            else:
-                # Since we want to give detailed sub-failure diax in case of BEFOREANDAFTER,
-                # economisng on the ifs below is tricky.
-                if when == APRIORI:
-                    try:
-                        assert eval(that)
-                    except AssertionError as exc:
-                        raise RequirementNotFulfilledError(that, when) from exc
-                    else:
-                        func(self, *pargs, **kwargs)
-
-                elif when == POSTMORTEM:
-                    func(self, *pargs, **kwargs)
-                    try:
-                        assert eval(that)
-                    except AssertionError as exc:
-                        raise RequirementNotFulfilledError(that, when) from exc
-
-                elif when == BEFOREANDAFTER:
-                    try:
-                        assert eval(that)
-                    except AssertionError as exc:
-                        raise RequirementNotFulfilledError(that, when, APRIORI) from exc
-                    else:
-                        func(self, *pargs, **kwargs)
-                    try:
-                        assert eval(that)
-                    except AssertionError as exc:
-                        raise RequirementNotFulfilledError(that, when, POSTMORTEM) from exc
-
-                # 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.
-
-        return inner_wrapper
-
-    return func_wrapper