pUnit 1.2.23__tar.gz → 1.2.26__tar.gz

{punit-1.2.23/src/pUnit.egg-info → punit-1.2.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pUnit
-Version: 1.2.23
+Version: 1.2.26
 Summary: A modernized unit-test framework for Python.
 Author-email: Shaun Wilson <mrshaunwilson@msn.com>
 License: MIT License

{punit-1.2.23 → punit-1.2.26}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pUnit"
-version = "1.2.23"
+version = "1.2.26"
 description = "A modernized unit-test framework for Python."
 keywords = ["test", "unittest", "unit-test", "xUnit", "nUnit", "pytest"]
 authors = [

{punit-1.2.23 → punit-1.2.26/src/pUnit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pUnit
-Version: 1.2.23
+Version: 1.2.26
 Summary: A modernized unit-test framework for Python.
 Author-email: Shaun Wilson <mrshaunwilson@msn.com>
 License: MIT License

{punit-1.2.23 → punit-1.2.26}/src/pUnit.egg-info/SOURCES.txt

@@ -25,6 +25,8 @@ src/punit/facts/__init__.py
 src/punit/filters/Filter.py
 src/punit/filters/FilterManager.py
 src/punit/filters/__init__.py
+src/punit/metadata/CallableMetadata.py
+src/punit/metadata/__init__.py
 src/punit/reports/HtmlReportGenerator.py
 src/punit/reports/JUnitReportGenerator.py
 src/punit/reports/__init__.py
@@ -32,4 +34,5 @@ src/punit/theories/Theory.py
 src/punit/theories/TheoryManager.py
 src/punit/theories/__init__.py
 src/punit/traits/Trait.py
+src/punit/traits/TraitManager.py
 src/punit/traits/__init__.py

{punit-1.2.23 → punit-1.2.26}/src/punit/__init__.py

@@ -7,14 +7,15 @@ from .theories import *
 from .traits import *
 
 
-__version__ = '1.2.23'
-__commit__ = '5327cc9'
+__version__ = '1.2.26'
+__commit__ = 'aeff39e'
 __all__ = [
     '__version__', '__commit__',
     'assertions',
     'collections', 'exceptions', 'strings',
     'facts',
     'fact',
+    'metadata',
     'theories',
     'theory', 'inlinedata',
     'traits',

punit-1.2.26/src/punit/facts/Fact.py

@@ -0,0 +1,55 @@
+# SPDX-FileCopyrightText: © 2024 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+import inspect
+from types import BuiltinFunctionType, BuiltinMethodType, FunctionType, MethodType, ModuleType
+from typing import Callable, Coroutine,  Union, cast
+
+from ..metadata import CallableMetadata
+
+
+class Fact:
+
+    __target:Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]
+
+    def __init__(self, target:Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]):
+        self.__metadata = CallableMetadata(target)
+        self.__target = target
+
+    @property
+    def metadata(self) -> CallableMetadata:
+        return self.__metadata
+
+    @property
+    def target(self) -> Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]:
+        return self.__target
+
+
+    async def execute(self, module:ModuleType) -> None:
+        coro:Coroutine|None = None
+        if hasattr(self.__target, '__qualname__') and self.__target.__qualname__.find('.') > -1:
+            if isinstance(self.__target, staticmethod):
+                coro = self.__target()
+            else:
+                qnparts = self.__target.__qualname__.split('.')
+                qntarget = module
+                for qnpart in qnparts[0:-1]:
+                    qntarget = getattr(qntarget, qnpart)
+                if isinstance(self.__target, classmethod):
+                    coro = self.__target.__func__(qntarget)
+                else:
+                    # every test execution gets a new instance of class
+                    coro = self.__target(cast(Callable,qntarget)())
+        else:
+            coro = self.__target()
+        if inspect.iscoroutine(coro):
+            await coro
+
+
+def fact(target:Callable) -> Callable:
+    from .FactManager import FactManager
+    if (not inspect.isfunction(target)) and (not isinstance(target, classmethod)) and (not isinstance(target, staticmethod)):
+        raise Exception('@fact can only be applied to functions and methods.')
+    fact:Fact = Fact(target)
+    FactManager.instance().put(fact)
+    return target

{punit-1.2.23 → punit-1.2.26}/src/punit/facts/FactManager.py

@@ -2,11 +2,11 @@
 # SPDX-License-Identifier: MIT
 ##
 
-import re
-from typing import Callable, Optional
+from typing import Optional
 
 from ..filters.FilterManager import FilterManager
 from ..traits.Trait import Trait
+from ..traits.TraitManager import TraitManager
 from .Fact import Fact
 
 
@@ -16,13 +16,11 @@ class FactManager:
     __instance:Optional['FactManager'] = None
     __includeTraits:list[Trait]
     __modules:dict[str, list[Fact]]
-    __traits:dict[Callable, list[Trait]]
     
     def __init__(self) -> None:
         if FactManager.__instance is not None:
             raise Exception('Cannot create more than one instance of FactManager') # pragma: no cover
         self.__modules = {}
-        self.__traits = {}
 
     @staticmethod
     def instance() -> 'FactManager':
@@ -47,14 +45,15 @@ class FactManager:
         self.__includeTraits = value
 
     def __excludeByTraits(self, fact:Fact) -> bool:
+        traits = TraitManager.instance().get(fact.target)
         if self.excludeTraits is not None and len(self.excludeTraits) > 0:
             for trait in self.excludeTraits:
-                for L_trait in fact.traits:
+                for L_trait in traits:
                     if trait.name == L_trait.name and (trait.value is None or (trait.value == L_trait.value)):
                         return True
         if self.includeTraits is not None and len(self.includeTraits) > 0:
             for trait in self.includeTraits:
-                for L_trait in fact.traits:
+                for L_trait in traits:
                     if trait.name == L_trait.name and (trait.value is None or (trait.value == L_trait.value)):
                         return False
             return True
@@ -71,21 +70,10 @@ class FactManager:
         filters = FilterManager.instance().filters
         matches_filter:bool = False
         for filter in filters:
-            if filter.re.fullmatch(fact.filterName) is not None:
+            if filter.re.fullmatch(fact.metadata.filterName) is not None:
                 matches_filter = not filter.isExclude
                 break
         if matches_filter:
-            l = self.get(fact.moduleName)
-            t = self.__traits.get(fact.target)
-            if t is not None:
-                for trait in t:
-                    fact.traits.append(trait)
+            l = self.get(fact.target.__module__)
             if not self.__excludeByTraits(fact):
                 l.append(fact)
-
-    def withTrait(self, target:Callable, trait:Trait) -> None:
-        t = self.__traits.get(target)
-        if t is None:
-            t = []
-            self.__traits[target] = t
-        t.append(trait)

punit-1.2.26/src/punit/metadata/CallableMetadata.py

@@ -0,0 +1,38 @@
+# SPDX-FileCopyrightText: © 2026 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+from types import BuiltinFunctionType, BuiltinMethodType, FunctionType, MethodType, ModuleType
+from typing import Callable, Optional, Union, cast
+
+
+class CallableMetadata:
+
+    __callable:Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]
+    __className:str
+    __moduleName:str
+    __name:str
+
+    def __init__(self, callable:Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]) -> None:
+        self.__callable = callable
+        self.__className = '.'.join(callable.__qualname__.replace(f'{callable.__module__}.', '').split('.')[0:-1])
+        self.__moduleName = callable.__module__
+        self.__name = callable.__name__
+
+    @property
+    def className(self) -> Optional[str]:
+        return self.__className
+
+    @property
+    def filterName(self) -> str:
+        """
+        The name used for pattern matched "Test Filtering".
+        """
+        return f'{".".join(self.__moduleName.split(".")[1:])}/{"" if self.__className is None else f"{self.__className}/"}{self.__name}'
+
+    @property
+    def moduleName(self) -> str:
+        return self.__moduleName
+
+    @property
+    def name(self) -> str:
+        return self.__name

punit-1.2.26/src/punit/metadata/__init__.py

@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: © 2026 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+from .CallableMetadata import CallableMetadata
+
+
+__all__ = [
+    'CallableMetadata'
+]

{punit-1.2.23 → punit-1.2.26}/src/punit/runner.py

@@ -6,8 +6,10 @@ import os
 import socket
 import time
 import traceback
+
 from .cli import CommandLineInterface
 from .facts.FactManager import FactManager
+from .metadata.CallableMetadata import CallableMetadata
 from .theories.TheoryManager import TheoryManager
 from .TestResult import TestResult
 
@@ -68,8 +70,8 @@ class TestRunner:
                         result.exception = ex
                     result.releaseOutput()
                     result.stopTime = time.time()
-                    result.className = fact.className
-                    result.testName = fact.testName
+                    result.className = fact.metadata.className
+                    result.testName = fact.metadata.name
                     results.append(result)
                     self.printTestResult(result)
                     if self.__cli.failfast and not result.isSuccess:
@@ -94,8 +96,8 @@ class TestRunner:
                             result.exception = ex
                         result.releaseOutput()
                         result.stopTime = time.time()
-                        result.className = theory.className
-                        result.testName = theory.testName
+                        result.className = theory.metadata.className
+                        result.testName = theory.metadata.name
                         results.append(result)
                         self.printTestResult(result)
                         if self.__cli.failfast and not result.isSuccess:

{punit-1.2.23 → punit-1.2.26}/src/punit/theories/Theory.py

@@ -3,79 +3,52 @@
 ##
 
 import inspect
-from types import FunctionType, MethodType, ModuleType
-from typing import Callable, Coroutine, Optional, cast
+from types import BuiltinFunctionType, BuiltinMethodType, FunctionType, MethodType, ModuleType
+from typing import Callable, Coroutine, Optional, Union, cast
 
-from ..traits.Trait import Trait
+from ..metadata import CallableMetadata
 
 
 class Theory:
 
-    __className:Optional[str]
     __datas:list[tuple]
-    __moduleName:str
-    __target:FunctionType|MethodType|Callable
-    __testName:Optional[str]
-    __traits:list[Trait]
+    __target:Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]
 
-    def __init__(self, moduleName:str, target:FunctionType|MethodType|Callable, className:Optional[str] = None, testName:Optional[str] = None):
-        self.__className = className
+    def __init__(self, target:Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]):
         self.__datas = []
-        self.__moduleName = moduleName
+        self.__metadata = CallableMetadata(target)
         self.__target = target
-        self.__testName = testName
-        self.__traits = []
-
-    @property
-    def className(self) -> Optional[str]:
-        return self.__className
 
     @property
     def datas(self) -> list[tuple]:
         return self.__datas
 
     @property
-    def moduleName(self) -> str:
-        return self.__moduleName
+    def metadata(self) -> CallableMetadata:
+        return self.__metadata
 
     @property
-    def target(self) -> FunctionType|MethodType|Callable:
+    def target(self) -> Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]:
         return self.__target
 
-    @property
-    def testName(self) -> str:
-        return self.__testName if self.__testName is not None else self.__target.__qualname__.split('.')[-1]
-
-    @property
-    def traits(self) -> list[Trait]:
-        return self.__traits
-
-    @property
-    def filterName(self) -> str:
-        return f'{self.moduleName}/{"" if self.className is None or len(self.className) == 0 else f"{self.className}/"}{self.testName}'
-
     async def execute(self, module:ModuleType, data:tuple) -> None:
         coro:Coroutine|None = None
         if hasattr(self.__target, '__qualname__') and self.__target.__qualname__.find('.') > -1:
             qnparts = self.__target.__qualname__.split('.')
             if isinstance(self.__target, staticmethod):
                 coro = self.__target(*data)
-                self.__className = '.'.join(qnparts[0:-1])
-                self.__testName = qnparts[-1]
             else:
                 qntarget = module
-                self.__testName = qnparts[-1]
-                self.__className = '.'.join(qnparts[0:-1])
                 for qnpart in qnparts[0:-1]:
                     qntarget = getattr(qntarget, qnpart)
                 if isinstance(self.__target, classmethod):
                     args = (qntarget,) + data
                     coro = self.__target.__func__(*args)
                 else:
+                    # every test execution gets a new instance of class
                     args = (cast(Callable,qntarget)(),) + data
                     coro = self.__target(*args)
         else:
-            self.__className = None
             self.__testName = self.__target.__name__
             coro = self.__target(*data)
         if inspect.iscoroutine(coro):
@@ -86,7 +59,7 @@ def theory(target:Callable) -> Callable:
     from .TheoryManager import TheoryManager
     if (not inspect.isfunction(target)) and (not isinstance(target, classmethod)) and (not isinstance(target, staticmethod)):
         raise Exception('@theory can only be applied to functions and methods.')
-    theory:Theory = Theory(target.__module__, target)
+    theory:Theory = Theory(target)
     TheoryManager.instance().put(theory)
     return target
 

{punit-1.2.23 → punit-1.2.26}/src/punit/theories/TheoryManager.py

@@ -2,11 +2,11 @@
 # SPDX-License-Identifier: MIT
 ##
 
-import re
 from typing import Callable, Optional
 
 from ..filters.FilterManager import FilterManager
 from ..traits.Trait import Trait
+from ..traits.TraitManager import TraitManager
 from .Theory import Theory
 
 
@@ -17,14 +17,12 @@ class TheoryManager:
     __instance:Optional['TheoryManager'] = None
     __modules:dict[str, list[Theory]]
     __datas:dict[Callable, list[tuple]]
-    __traits:dict[Callable, list[Trait]]
     
     def __init__(self) -> None:
         if TheoryManager.__instance is not None:
             raise Exception('Cannot create more than one instance of TheoryManager') # pragma: no cover
         self.__modules = {}
         self.__datas = {}
-        self.__traits = {}
 
     @staticmethod
     def instance() -> 'TheoryManager':
@@ -49,14 +47,15 @@ class TheoryManager:
         self.__includeTraits = value
 
     def __excludeByTraits(self, theory:Theory) -> bool:
+        traits = TraitManager.instance().get(theory.target)
         if self.excludeTraits is not None and len(self.__excludeTraits) > 0:
             for trait in self.excludeTraits:
-                for L_trait in theory.traits:
+                for L_trait in traits:
                     if trait.name == L_trait.name and (trait.value is None or (trait.value == L_trait.value)):
                         return True
         if self.includeTraits is not None and len(self.includeTraits) > 0:
             for trait in self.includeTraits:
-                for L_trait in theory.traits:
+                for L_trait in traits:
                     if trait.name == L_trait.name and (trait.value is None or (trait.value == L_trait.value)):
                         return False
             return True
@@ -73,20 +72,16 @@ class TheoryManager:
         filters = FilterManager.instance().filters
         matches_filter:bool = False
         for filter in filters:
-            if filter.re.fullmatch(theory.filterName) is not None:
+            if filter.re.fullmatch(theory.metadata.filterName) is not None:
                 matches_filter = not filter.isExclude
                 break
         if matches_filter:
-            l = self.get(theory.moduleName)
+            l = self.get(theory.target.__module__)
             d = self.__datas.get(theory.target)
             if d is not None:
                 d.reverse()
                 for data in d:
                     theory.datas.append(data)
-            t = self.__traits.get(theory.target)
-            if t is not None:
-                for trait in t:
-                    theory.traits.append(trait)
             if not self.__excludeByTraits(theory):
                 l.append(theory)
 
@@ -99,10 +94,3 @@ class TheoryManager:
             d = []
             self.__datas[target] = d
         d.append(data)
-
-    def withTrait(self, target:Callable, trait:Trait) -> None:
-        t = self.__traits.get(target)
-        if t is None:
-            t = []
-            self.__traits[target] = t
-        t.append(trait)

{punit-1.2.23 → punit-1.2.26}/src/punit/traits/Trait.py

@@ -25,10 +25,8 @@ class Trait:
 
 def trait(name:str, value:Optional[str]=None) -> Callable:
     def wrapper(target:Callable) -> Callable:
-        from ..theories.TheoryManager import TheoryManager
-        from ..facts.FactManager import FactManager
+        from .TraitManager import TraitManager
         trait = Trait(name, value)
-        TheoryManager.instance().withTrait(target, trait)
-        FactManager.instance().withTrait(target, trait)
+        TraitManager.instance().put(target, trait)
         return target
     return wrapper

punit-1.2.26/src/punit/traits/TraitManager.py

@@ -0,0 +1,39 @@
+# SPDX-FileCopyrightText: © 2026 Shaun Wilson
+# SPDX-License-Identifier: MIT
+##
+
+from types import FunctionType, MethodType
+from typing import Callable, Optional
+
+from .Trait import Trait
+
+
+class TraitManager:
+
+    __instance:Optional['TraitManager'] = None
+    __traits:dict[Callable|FunctionType|MethodType, dict[str, Trait]]
+    
+    def __init__(self) -> None:
+        if TraitManager.__instance is not None:
+            raise Exception('Cannot create more than one instance of TraitManager') # pragma: no cover
+        self.__traits = dict[Callable|FunctionType|MethodType, dict[str, Trait]]()
+
+    @staticmethod
+    def instance() -> 'TraitManager':
+        if TraitManager.__instance is None:
+            TraitManager.__instance = TraitManager()
+        return TraitManager.__instance
+    
+    def get(self, callable:Callable|FunctionType|MethodType) -> list[Trait]:
+        d = self.__traits.get(callable)
+        if d is None:
+            d = dict[str, Trait]()
+            self.__traits[callable] = d
+        return [e for e in d.values()]
+
+    def put(self, callable:Callable, trait:Trait) -> None:
+        d = self.__traits.get(callable)
+        if d is None:
+            d = dict[str,Trait]()
+            self.__traits[callable] = d
+        d[trait.name] = trait

{punit-1.2.23 → punit-1.2.26}/src/punit/traits/__init__.py

@@ -1,9 +1,11 @@
 # SPDX-FileCopyrightText: © 2024 Shaun Wilson
 # SPDX-License-Identifier: MIT
 
+from .TraitManager import TraitManager
 from .Trait import Trait, trait
 
 
 __all__ = [
+    'TraitManager',
     'Trait', 'trait'
 ]

punit-1.2.23/src/punit/facts/Fact.py

@@ -1,82 +0,0 @@
-# SPDX-FileCopyrightText: © 2024 Shaun Wilson
-# SPDX-License-Identifier: MIT
-
-import inspect
-from types import FunctionType, MethodType, ModuleType
-from typing import Callable, Coroutine, Optional, cast
-
-from ..traits.Trait import Trait
-
-
-class Fact:
-
-    __className:Optional[str]
-    __moduleName:str
-    __target:FunctionType|MethodType|Callable
-    __testName:Optional[str]
-    __traits:list[Trait]
-
-    def __init__(self, moduleName:str, target:FunctionType|MethodType|Callable, className:Optional[str] = None, testName:Optional[str] = None):
-        self.__className = className
-        self.__moduleName = moduleName
-        self.__target = target
-        self.__testName = testName
-        self.__traits = []
-
-    @property
-    def className(self) -> Optional[str]:
-        return self.__className
-
-    @property
-    def moduleName(self) -> str:
-        return self.__moduleName
-
-    @property
-    def target(self) -> FunctionType|MethodType|Callable:
-        return self.__target
-
-    @property
-    def testName(self) -> str:
-        return self.__testName if self.__testName is not None else self.__target.__qualname__.split('.')[-1]
-    
-    @property
-    def filterName(self) -> str:
-        return f'{self.moduleName}/{"" if self.className is None or len(self.className) == 0 else f"{self.className}/"}{self.testName}'
-
-    @property
-    def traits(self) -> list[Trait]:
-        return self.__traits
-
-    async def execute(self, module:ModuleType) -> None:
-        coro:Coroutine|None = None
-        if hasattr(self.__target, '__qualname__') and self.__target.__qualname__.find('.') > -1:
-            qnparts = self.__target.__qualname__.split('.')
-            if isinstance(self.__target, staticmethod):
-                coro = self.__target()
-                self.__className = '.'.join(qnparts[0:-1])
-                self.__testName = qnparts[-1]
-            else:
-                qntarget = module
-                self.__className = '.'.join(qnparts[0:-1])
-                self.__testName = qnparts[-1]
-                for qnpart in qnparts[0:-1]:
-                    qntarget = getattr(qntarget, qnpart)
-                if isinstance(self.__target, classmethod):
-                    coro = self.__target.__func__(qntarget)
-                else:
-                    coro = self.__target(cast(Callable,qntarget)())
-        else:
-            self.__className = None
-            self.__testName = self.__target.__name__
-            coro = self.__target()
-        if inspect.iscoroutine(coro):
-            await coro
-
-
-def fact(target:Callable) -> Callable:
-    from .FactManager import FactManager
-    if (not inspect.isfunction(target)) and (not isinstance(target, classmethod)) and (not isinstance(target, staticmethod)):
-        raise Exception('@fact can only be applied to functions and methods.')
-    fact:Fact = Fact(target.__module__, target)
-    FactManager.instance().put(fact)
-    return target