strictabc 1.0.0__tar.gz

strictabc-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 taviken
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

strictabc-1.0.0/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: strictabc
+Version: 1.0.0
+Summary: A module containing the implementation of Strict ABC classes and decorators
+Author-email: Trevor Viken <trevor.viken@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/taviken/strictabc
+Project-URL: Issues, https://github.com/taviken/strictabc/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file

strictabc-1.0.0/README.rst

@@ -0,0 +1,11 @@
+# strictabc
+Repository of python package strictabc
+
+
+License
+-------
+
+Licensed under the `MIT License`_.
+
+.. _MIT License: https://github.com/taviken/strictabc/blob/main/LICENSE
+

strictabc-1.0.0/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "strictabc"
+version = "1.0.0"
+authors = [
+  { name="Trevor Viken", email="trevor.viken@gmail.com" },
+]
+description = "A module containing the implementation of Strict ABC classes and decorators"
+readme = "README.md"
+requires-python = ">=3.10"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[project.urls]
+Homepage = "https://github.com/taviken/strictabc"
+Issues = "https://github.com/taviken/strictabc/issues"

strictabc-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

strictabc-1.0.0/src/strictabc/__init__.py

@@ -0,0 +1,3 @@
+from .strict import *
+
+__version__ = "0.0.1"

strictabc-1.0.0/src/strictabc/strict.py

@@ -0,0 +1,152 @@
+"""
+This module contains the implementation of Strict ABC classes and decorators
+"""
+
+from abc import ABCMeta, abstractmethod, ABC
+from typing import Mapping, List, Tuple, Iterable, Callable, Any
+from inspect import signature
+from collections import namedtuple
+
+_sentinel = object()
+
+miss_matched_sigs = namedtuple(
+    "miss_matched_sigs", ["method_name", "good_sig", "bad_sig"]
+)
+
+__strict_signature__ = "__strict_signature__"
+
+
+class StrictAbstractError(AttributeError):
+    """Metaclass for defining Strict Abstract Base Classes (ABCs).
+
+    Use this metaclass to create an Strict ABC.  An ABC can be subclassed
+    directly, and then acts as a mix-in class.  You can also register
+    unrelated concrete classes (even built-in classes) and unrelated
+    ABCs as 'virtual subclasses' -- these and their descendants will
+    be considered subclasses of the registering ABC by the built-in
+    issubclass() function, but the registering ABC won't show up in
+    their MRO (Method Resolution Order) nor will method
+    implementations defined by the registering ABC be callable (not
+    even via super()).
+
+    This Class will throw an Attribute like error upon detecting un implemented
+    methods in the Concrete class at compile time.
+    """
+
+    def __init__(
+        self, name: str, missing: List[str], bad_sigs: List[miss_matched_sigs]
+    ):
+        missing_methods = f"Missing methods: {missing}"
+        missmatch = f"Missmatched signatures detected: {bad_sigs}"
+        msg = f"Errors in <{name}>\n{missing_methods}\n{missmatch}"
+        super().__init__(msg)
+
+
+def strictabstract(funcobj: Callable):
+    """A decorator indicating strict abstract methods.
+
+    Requires that the metaclass is StrictABCMeta or derived from it.  A
+    class that has a metaclass derived from StrictABCMeta cannot be
+    compiled unless all of its abstract methods are overridden.
+    The abstract methods can be called using any of the normal
+    'super' call mechanisms.  strictabstract() may be used to declare
+    abstract methods for properties and descriptors.
+
+    Usage:
+
+        class C(metaclass=StrictABCMeta):
+            @strictabstract
+            def my_abstract_method(self, arg1, arg2, argN):
+                ...
+    """
+    sig = signature(funcobj)
+    setattr(funcobj, __strict_signature__, sig)
+    funcobj.__isabstractmethod__ = True
+    return funcobj
+
+
+class StrictABCMeta(ABCMeta):
+    def __new__(
+        mcls,
+        name: str,
+        bases: Tuple[object],
+        classdict: Mapping[str, object],
+        /,
+        **kwargs: Mapping[Any, Any],
+    ):
+
+        cls = super().__new__(mcls, name, bases, classdict, **kwargs)
+
+        mcls._check_bases(mcls, bases, classdict)
+
+        return cls
+
+    def _check_bases(
+        mcls, bases: Iterable[Tuple[object]], classdict: Mapping[str, object]
+    ):
+        for base in bases:
+
+            # filter on only methods, and are abstract
+            base_methods = dict(
+                (method_name, method)
+                for method_name, method in vars(base).items()
+                if callable(method) and method_name in base.__abstractmethods__
+            )
+
+            # check for missing and bad signatures
+            mcls._check_missmatch(mcls, base_methods, classdict)
+
+    def _check_missmatch(
+        mcls, base_methods: Mapping[str, Callable], classdict: Mapping[str, object]
+    ):
+        missing = []
+        bad_sigs = []
+        # loop through base classes
+        for method_name, method in base_methods.items():
+            # grab corresponding concrete method
+            concrete_method = classdict.get(method_name, _sentinel)
+
+            # if no concrete method found, append to missing and continue
+            if concrete_method is _sentinel:
+                missing.append(method_name)
+                continue
+
+            # get base method signature
+            base_sig = getattr(method, __strict_signature__)
+
+            # get signature fro concrete method
+            if isinstance(concrete_method, classmethod):
+                # concrete method is classmethod, handle grab sig differently
+                concrete_sig = signature(concrete_method.__func__)
+            else:
+                concrete_sig = signature(concrete_method)
+
+            # if base and concrete signatures don't match, append to bad sigs
+            if concrete_sig != base_sig:
+                bad_sig = miss_matched_sigs(
+                    method_name=classdict["__qualname__"],
+                    good_sig=base_sig,
+                    bad_sig=concrete_sig,
+                )
+                bad_sigs.append(bad_sig)
+                continue  # this onctinue added in case of future improvement
+
+        # if either missing or bad sigs found raise exception here
+        if missing or bad_sigs:
+            raise StrictAbstractError(mcls.__name__, missing, bad_sigs)
+
+
+class StrictABC(metaclass=StrictABCMeta):
+    pass
+
+
+__all__ = [
+    "StrictABC",
+    "StrictABCMeta",
+    "strictabstract",
+    "StrictAbstractError",
+    # adding regular abc items from package here
+    "ABC",
+    "ABCMeta",
+    "abstractmethod",
+]

strictabc-1.0.0/src/strictabc.egg-info/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.4
+Name: strictabc
+Version: 1.0.0
+Summary: A module containing the implementation of Strict ABC classes and decorators
+Author-email: Trevor Viken <trevor.viken@gmail.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/taviken/strictabc
+Project-URL: Issues, https://github.com/taviken/strictabc/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file

strictabc-1.0.0/src/strictabc.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.rst
+pyproject.toml
+src/strictabc/__init__.py
+src/strictabc/strict.py
+src/strictabc.egg-info/PKG-INFO
+src/strictabc.egg-info/SOURCES.txt
+src/strictabc.egg-info/dependency_links.txt
+src/strictabc.egg-info/top_level.txt
+tests/test_strict_abstract.py

strictabc-1.0.0/src/strictabc.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

strictabc-1.0.0/src/strictabc.egg-info/top_level.txt

@@ -0,0 +1 @@
+strictabc

strictabc-1.0.0/tests/test_strict_abstract.py

@@ -0,0 +1,79 @@
+from strictabc import *
+import pytest
+
+
+@pytest.fixture
+def setup():
+    class Foo(metaclass=StrictABCMeta):
+        @strictabstract
+        def bar(self):
+            pass
+
+        @strictabstract
+        def baz(self, a):
+            pass
+
+    class Foo2(StrictABC):
+        @strictabstract
+        def bar(self):
+            pass
+
+        @strictabstract
+        def baz(self, a):
+            pass
+
+    return Foo, Foo2
+
+
+def test_strict_abc_meta(setup):
+
+    Foo, Foo2 = setup
+
+    class ConFooPass(Foo):
+        def bar(self):
+            print("happy")
+
+        def baz(self, a):
+            print(a)
+
+    assert ConFooPass()
+
+    class ConFooPassClass(Foo):
+        @classmethod
+        def bar(self):
+            print("happy")
+
+        def baz(self, a):
+            print(a)
+
+    assert ConFooPassClass()
+
+    class ConFooPassClass2(Foo2):
+        @classmethod
+        def bar(self):
+            print("happy")
+
+        def baz(self, a):
+            print(a)
+
+    assert ConFooPassClass2()
+
+
+def test_fail_missing(setup):
+    Foo, _ = setup
+    with pytest.raises(StrictAbstractError):
+
+        class ConFooFailMissing(Foo):
+            pass
+
+
+def test_fail_missmatch(setup):
+    Foo, _ = setup
+    with pytest.raises(StrictAbstractError):
+
+        class ConFooFailSig(Foo):
+            def bar(cls):
+                print("happy")
+
+            def baz(self, A):
+                print(A)