requiresthat 2025.6.17.0__tar.gz → 2025.6.18.1__tar.gz

{requiresthat-2025.6.17.0 → requiresthat-2025.6.18.1}/PKG-INFO

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

{requiresthat-2025.6.17.0 → requiresthat-2025.6.18.1}/pyproject.toml

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

requiresthat-2025.6.18.1/src/requiresthat/__init__.py

@@ -0,0 +1,8 @@
+from ._requires import (
+    requires,
+    RequirementNotFulfilledError,
+    NoCallableConstructError,
+    APRIORI,
+    POSTMORTEM,
+    BEFOREANDAFTER,
+)

requiresthat-2025.6.18.1/src/requiresthat/_exceptions.py

@@ -0,0 +1,34 @@
+import textwrap
+
+class RequirementNotFulfilledError(Exception):
+    """Raise this when a requirement is found wanting"""
+
+    def __init__(self, that, when, subwhen=str(), msg=None):
+        """Show a default or a user-provided message indicating that some condition is unmet"""
+
+        if subwhen:
+            subwhen = f' ({subwhen.name!r})'
+        self.default_msg = textwrap.dedent(f"""
+            {that!r} ({when.name!r}{subwhen}) does not hold
+        """).strip()
+
+        # Call the base class' constructor to init the exception class
+        super().__init__(msg or self.default_msg)
+
+class NoCallableConstructError(Exception):
+    """Raise this when a construct is not callable"""
+
+    def __init__(self, construct, msg=None):
+        """Show a default or a user-provided message"""
+
+        self.default_msg = textwrap.dedent(f"""
+            {construct!r} does not seem to be callable
+
+            You have managed to place the decorator before a construct that is not callable
+            *without* tripping the Python interpreter.  Maybe you are a wizard?
+
+            But, no, we can't carry on like that.  Sorry!
+        """).strip()
+
+        # Call the base class' constructor to init the exception class
+        super().__init__(msg or self.default_msg)

requiresthat-2025.6.18.1/src/requiresthat/_requires.py

@@ -0,0 +1,61 @@
+"""See the README 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

{requiresthat-2025.6.17.0 → requiresthat-2025.6.18.1}/src/requiresthat.egg-info/PKG-INFO

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

requiresthat-2025.6.17.0/src/requiresthat/__init__.py

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

requiresthat-2025.6.17.0/src/requiresthat/_exceptions.py

@@ -1,15 +0,0 @@
-"""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-2025.6.17.0/src/requiresthat/_requires.py

@@ -1,40 +0,0 @@
-"""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