punit 1.5.2__tar.gz → 1.5.3__tar.gz

{punit-1.5.2/src/pUnit.egg-info → punit-1.5.3}/PKG-INFO

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

{punit-1.5.2 → punit-1.5.3}/pyproject.toml

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

{punit-1.5.2 → punit-1.5.3/src/pUnit.egg-info}/PKG-INFO

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

punit-1.5.3/src/punit/TestResult.py

@@ -0,0 +1,186 @@
+# SPDX-FileCopyrightText: © 2024 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+import sys
+from typing import Any, TextIO, Optional, cast
+
+
+class TextIOCapture:
+
+    __quiet: bool
+    output: str | None = None
+    target: TextIO
+
+    def __init__(self, target: TextIO, quiet: bool = False) -> None:
+        self.__quiet = quiet
+        self.output = None
+        self.target = target
+
+    def write(self, text: str) -> int:
+        if self.output is None:
+            self.output = text
+        else:
+            self.output += text
+        if not self.__quiet:
+            self.target.write(text)
+        return len(text)
+
+
+class TestResult:
+
+    __class_name: Optional[str]
+    __exception: Exception | None
+    __file_name: str | None
+    __host_name: str | None
+    __is_success: bool | None
+    __module_name: str | None
+    __package_name: str | None
+    __properties: dict[str, Any]
+    __start_time: float | None
+    __stderr_capture: TextIOCapture | None
+    __stdout_capture: TextIOCapture | None
+    __stop_time: float | None
+    __test_name: str | None
+
+    def __init__(self) -> None:
+        self.__class_name = None
+        self.__exception = None
+        self.__file_name = None
+        self.__host_name = None
+        self.__is_success = None
+        self.__module_name = None
+        self.__package_name = None
+        self.__properties = dict[str, Any]()
+        self.__start_time = None
+        self.__stderr_capture = None
+        self.__stdout_capture = None
+        self.__stop_time = None
+        self.__test_name = None
+
+    @property
+    def class_name(self) -> Optional[str]:
+        return self.__class_name if self.__class_name is not None and len(self.__class_name) > 0 else None
+
+    @class_name.setter
+    def class_name(self, value: Optional[str]) -> None:
+        self.__class_name = value
+
+    @property
+    def exception(self) -> Exception | None:
+        return self.__exception
+
+    @exception.setter
+    def exception(self, value: Exception) -> None:
+        self.__exception = value
+
+    @property
+    def file_name(self) -> str | None:
+        return self.__file_name
+
+    @file_name.setter
+    def file_name(self, value: str) -> None:
+        self.__file_name = value
+
+    @property
+    def host_name(self) -> str | None:
+        return self.__host_name
+
+    @host_name.setter
+    def host_name(self, value: str) -> None:
+        self.__host_name = value
+
+    @property
+    def is_success(self) -> bool:
+        return False if self.__is_success is None else self.__is_success
+
+    @is_success.setter
+    def is_success(self, value: bool) -> None:
+        self.__is_success = value
+
+    @property
+    def module_name(self) -> str:
+        return cast(str, self.__module_name)
+
+    @module_name.setter
+    def module_name(self, value: str) -> None:
+        self.__module_name = value
+
+    @property
+    def package_name(self) -> str | None:
+        return self.__package_name
+
+    @package_name.setter
+    def package_name(self, value: str) -> None:
+        self.__package_name = value
+
+    @property
+    def properties(self) -> dict[str, Any]:
+        return self.__properties
+
+    @properties.setter
+    def properties(self, value: dict[str, str]) -> None:
+        self.__properties = value
+
+    @property
+    def start_time(self) -> float | None:
+        return self.__start_time
+
+    @start_time.setter
+    def start_time(self, value: float) -> None:
+        self.__start_time = value
+
+    @property
+    def stderr(self) -> str | None:
+        return None if self.__stderr_capture is None else self.__stderr_capture.output
+
+    @property
+    def stdout(self) -> str | None:
+        return None if self.__stdout_capture is None else self.__stdout_capture.output
+
+    @property
+    def stop_time(self) -> float | None:
+        return self.__stop_time
+
+    @stop_time.setter
+    def stop_time(self, value: float) -> None:
+        self.__stop_time = value
+
+    @property
+    def test_name(self) -> str | None:
+        return self.__test_name
+
+    @test_name.setter
+    def test_name(self, value: str) -> None:
+        self.__test_name = value
+
+    @property
+    def took(self) -> float | None:
+        return None if self.__stop_time is None or self.__start_time is None else self.__stop_time - self.__start_time
+
+    @property
+    def tookPretty(self) -> str:
+        took = self.took
+        if took is None:
+            return 'N/A'
+        elif took >= 1:
+            return f'{took:.1f}'.rstrip('0').rstrip('.') + 's'
+        elif took >= 0.001:
+            return f'{(took*1000):.0f}ms'
+        elif took >= 0.000001:
+            return f'{(took*1000):.3f}'.rstrip('0').rstrip('.') + 'ms'
+        elif took >= 0.000000001:
+            return f'{(took*1000000):.3f}'.rstrip('0').rstrip('.') + 'μs'
+        else:
+            return f'{(took*1000):.3f}'.rstrip('0').rstrip('.') + 'ms'
+
+    def captureOutput(self, quiet: bool = False) -> None:
+        self.__stdout_capture = TextIOCapture(sys.stdout, quiet)
+        self.__stderr_capture = TextIOCapture(sys.stderr, quiet)
+        sys.stdout = self.__stdout_capture
+        sys.stderr = self.__stderr_capture
+
+    def releaseOutput(self) -> None:
+        if self.__stdout_capture is not None and self.__stdout_capture.target is not None:
+            sys.stdout = self.__stdout_capture.target
+        if self.__stderr_capture is not None and self.__stderr_capture.target is not None:
+            sys.stderr = self.__stderr_capture.target

{punit-1.5.2 → punit-1.5.3}/src/punit/__init__.py

@@ -10,8 +10,8 @@ from .assertions.exceptions import raises
 from .assertions.numeric import approx
 
 
-__version__ = '1.5.2'
-__commit__ = '19ca1ae'
+__version__ = '1.5.3'
+__commit__ = '34475af'
 __all__ = [
     '__version__', '__commit__',
     'assertions',

{punit-1.5.2 → punit-1.5.3}/src/punit/__main__.py

@@ -31,17 +31,17 @@ async def async_main() -> None:
         if pathbase not in sys.path:
             sys.path.append(pathbase)
     testModuleDiscovery = TestModuleDiscovery(
-        os.path.join(cli.workdir, cli.testPackageName),
+        os.path.join(cli.workdir, cli.test_package_name),
         cli.includePatterns,
         cli.excludePatterns,
         cli)
     testModuleDiscovery.discover()
-    testRunner = TestRunner(cli.testPackageName, testModuleDiscovery.filenames, cli)
+    testRunner = TestRunner(cli.test_package_name, testModuleDiscovery.filenames, cli)
     results = await testRunner.run()
     totalTime = time.time() - ts
     failureCount = 0
     for result in results:
-        if not result.isSuccess:
+        if not result.is_success:
             failureCount += 1  # pragma: no cover
     if not cli.quiet:
         print(f'Total: {len(results)}, Failures: {failureCount}, Took: {totalTime:.3f}s')

{punit-1.5.2 → punit-1.5.3}/src/punit/assertions/numeric.py

@@ -79,7 +79,7 @@ def isclose(
         a_c = a if isinstance(a, complex) else complex(a, 0)
         b_c = b if isinstance(b, complex) else complex(b, 0)
         return math.isclose(a_c.real, b_c.real, rel_tol=rel_tol, abs_tol=abs_tol) and \
-               math.isclose(a_c.imag, b_c.imag, rel_tol=rel_tol, abs_tol=abs_tol)
+            math.isclose(a_c.imag, b_c.imag, rel_tol=rel_tol, abs_tol=abs_tol)
 
     # Both real: delegate to stdlib (safe float cast for int/float)
     return math.isclose(float(a), float(b), rel_tol=rel_tol, abs_tol=abs_tol)

{punit-1.5.2 → punit-1.5.3}/src/punit/cli.py

@@ -24,7 +24,7 @@ class CommandLineInterface:
     __outputFilename: Optional[str]
     __quiet: bool
     __reportFormat: Optional[str]
-    __testPackageName: str | None
+    __test_package_name: str | None
     __verbose: bool
     __workdir: str | None
 
@@ -42,7 +42,7 @@ class CommandLineInterface:
         self.__outputFilename = None
         self.__quiet = False
         self.__reportFormat = None
-        self.__testPackageName = 'tests'
+        self.__test_package_name = 'tests'
         self.__workdir = os.path.curdir
         self.__verbose = False
 
@@ -92,8 +92,8 @@ class CommandLineInterface:
             elif self.__workdir is None:
                 self.__workdir = arg
                 continue
-            elif self.__testPackageName is None:
-                self.__testPackageName = arg
+            elif self.__test_package_name is None:
+                self.__test_package_name = arg
                 continue
             elif extractReportFormat:
                 extractReportFormat = False
@@ -122,7 +122,7 @@ class CommandLineInterface:
                 case '-z' | '--failfast':
                     self.__failfast = True
                 case '-p' | '--test-package':
-                    self.__testPackageName = None
+                    self.__test_package_name = None
                 case '-i' | '--include':
                     extractIncludePattern = True
                 case '-q' | '--quiet':
@@ -198,8 +198,8 @@ class CommandLineInterface:
         return self.__reportFormat
 
     @property
-    def testPackageName(self) -> str:
-        return 'tests' if self.__testPackageName is None else self.__testPackageName
+    def test_package_name(self) -> str:
+        return 'tests' if self.__test_package_name is None else self.__test_package_name
 
     @property
     def verbose(self) -> bool:
@@ -307,7 +307,7 @@ Options:
             os._exit(2)
         self.__workdir = os.path.abspath(self.__workdir)
         if not self.__no_default_patterns:
-            # if no other patterns specified, default to including all files found in the directory matching `testPackageName`
+            # if no other patterns specified, default to including all files found in the directory matching `test_package_name`
             if len(self.__includePatterns) == 0:
                 self.__includePatterns.append('*.py')
             # always exclude dunder files

{punit-1.5.2 → punit-1.5.3}/src/punit/discovery/TestModuleDiscovery.py

@@ -12,15 +12,15 @@ from ..traits import Trait
 
 class TestModuleDiscovery:
 
-    __cli:CommandLineInterface
-    __excludePatterns:list[re.Pattern]
-    __excludeTraits:list[Trait]
-    __filenames:list[str]
-    __includePatterns:list[re.Pattern]
-    __includeTraits:list[Trait]
-    __workdir:str
+    __cli: CommandLineInterface
+    __excludePatterns: list[re.Pattern]
+    __excludeTraits: list[Trait]
+    __filenames: list[str]
+    __includePatterns: list[re.Pattern]
+    __includeTraits: list[Trait]
+    __workdir: str
 
-    def __init__(self, workdir:str, includePatterns:list[str], excludePatterns:list[str], cli:CommandLineInterface) -> None:
+    def __init__(self, workdir: str, includePatterns: list[str], excludePatterns: list[str], cli: CommandLineInterface) -> None:
         self.__cli = cli
         self.__excludePatterns = []
         if excludePatterns is not None:
@@ -41,27 +41,26 @@ class TestModuleDiscovery:
                         re.IGNORECASE))
         self.__workdir = workdir
 
-
-    def __convertPatternToRegex(self, pattern:str) -> str:
+    def __convertPatternToRegex(self, pattern: str) -> str:
         result = re.escape(pattern)\
             .replace('\\\\', '/')\
             .replace('\\*', r'.*')\
             .replace('?', '.')
         return result
 
-    def __testAnyInclude(self, input:str) -> bool:
+    def __testAnyInclude(self, input: str) -> bool:
         for pat in self.__includePatterns:
             if len(pat.findall(input)) > 0:
                 return True
         return False
 
-    def __testAnyExclude(self, input:str) -> bool:
+    def __testAnyExclude(self, input: str) -> bool:
         for pat in self.__excludePatterns:
             if len(pat.findall(input)) > 0:
                 return True
         return False
 
-    def __walkDirectory(self, path:str) -> list[str]:
+    def __walkDirectory(self, path: str) -> list[str]:
         filenames = []
         if os.path.isdir(path):
             for dname, dlist, flist in os.walk(path, topdown=True):
@@ -97,7 +96,7 @@ class TestModuleDiscovery:
     @property
     def filenames(self) -> list[str]:
         return self.__filenames
-        
+
     def discover(self) -> list[str]:
         FactManager.instance().excludeTraits = self.__excludeTraits
         FactManager.instance().includeTraits = self.__includeTraits

{punit-1.5.2 → punit-1.5.3}/src/punit/facts/Fact.py

@@ -3,16 +3,16 @@
 
 import inspect
 from types import BuiltinFunctionType, BuiltinMethodType, FunctionType, MethodType, ModuleType
-from typing import Callable, Coroutine,  Union, cast
+from typing import Callable, Coroutine, Union, cast
 
 from ..metadata import CallableMetadata
 
 
 class Fact:
 
-    __target:Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]
+    __target: Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]
 
-    def __init__(self, target:Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]):
+    def __init__(self, target: Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]):
         self.__metadata = CallableMetadata(target)
         self.__target = target
 
@@ -24,9 +24,8 @@ class Fact:
     def target(self) -> Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]:
         return self.__target
 
-
-    async def execute(self, module:ModuleType) -> None:
-        coro:Coroutine|None = None
+    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()
@@ -39,17 +38,17 @@ class Fact:
                     coro = self.__target.__func__(qntarget)
                 else:
                     # every test execution gets a new instance of class
-                    coro = self.__target(cast(Callable,qntarget)())
+                    coro = self.__target(cast(Callable, qntarget)())
         else:
             coro = self.__target()
         if inspect.iscoroutine(coro):
             await coro
 
 
-def fact(target:Callable) -> Callable:
+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)
+    fact: Fact = Fact(target)
     FactManager.instance().put(fact)
     return target

{punit-1.5.2 → punit-1.5.3}/src/punit/facts/FactManager.py

@@ -12,14 +12,14 @@ from .Fact import Fact
 
 class FactManager:
 
-    __excludeTraits:list[Trait]    
-    __instance:Optional['FactManager'] = None
-    __includeTraits:list[Trait]
-    __modules:dict[str, list[Fact]]
-    
+    __excludeTraits: list[Trait]
+    __instance: Optional['FactManager'] = None
+    __includeTraits: list[Trait]
+    __modules: dict[str, list[Fact]]
+
     def __init__(self) -> None:
         if FactManager.__instance is not None:
-            raise Exception('Cannot create more than one instance of FactManager') # pragma: no cover
+            raise Exception('Cannot create more than one instance of FactManager')  # pragma: no cover
         self.__modules = {}
 
     @staticmethod
@@ -27,24 +27,24 @@ class FactManager:
         if FactManager.__instance is None:
             FactManager.__instance = FactManager()
         return FactManager.__instance
-    
+
     @property
     def excludeTraits(self) -> list[Trait]:
         return [] if self.__excludeTraits is None else self.__excludeTraits
 
     @excludeTraits.setter
-    def excludeTraits(self, value:list[Trait]) -> None:
+    def excludeTraits(self, value: list[Trait]) -> None:
         self.__excludeTraits = value
 
     @property
     def includeTraits(self) -> list[Trait]:
         return [] if self.__includeTraits is None else self.__includeTraits
-    
+
     @includeTraits.setter
-    def includeTraits(self, value:list[Trait]) -> None:
+    def includeTraits(self, value: list[Trait]) -> None:
         self.__includeTraits = value
 
-    def __excludeByTraits(self, fact:Fact) -> bool:
+    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:
@@ -59,18 +59,18 @@ class FactManager:
             return True
         return False
 
-    def get(self, moduleName:str) -> list[Fact]:
-        l = self.__modules.get(moduleName)
+    def get(self, module_name: str) -> list[Fact]:
+        l = self.__modules.get(module_name)
         if l is None:
             l = []
-            self.__modules[moduleName] = l
+            self.__modules[module_name] = l
         return l
 
-    def put(self, fact:Fact) -> None:
+    def put(self, fact: Fact) -> None:
         filters = FilterManager.instance().filters
-        matches_filter:bool = False
+        matches_filter: bool = False
         for filter in filters:
-            if filter.re.fullmatch(fact.metadata.filterName) is not None:
+            if filter.re.fullmatch(fact.metadata.filter_name) is not None:
                 matches_filter = not filter.isExclude
                 break
         if matches_filter:

{punit-1.5.2 → punit-1.5.3}/src/punit/filters/Filter.py

@@ -6,16 +6,16 @@ import re
 
 class Filter:
 
-    __isExclude:bool
-    __pattern:str
-    __re:re.Pattern
+    __isExclude: bool
+    __pattern: str
+    __re: re.Pattern
 
-    def __init__(self, pattern:str) -> None:
+    def __init__(self, pattern: str) -> None:
         self.__isExclude = pattern.startswith('!')
         self.__pattern = pattern
         self.__re = self.__toRegex(pattern)
 
-    def __toRegex(self, pattern:str) -> re.Pattern:
+    def __toRegex(self, pattern: str) -> re.Pattern:
         if self.__isExclude:
             pattern = pattern[1:]
         pattern = re.escape(pattern)\
@@ -27,11 +27,11 @@ class Filter:
     @property
     def isExclude(self) -> bool:
         return self.__isExclude
-    
+
     @property
     def pattern(self) -> str:
         return self.__pattern
-    
+
     @property
     def re(self) -> re.Pattern:
         return self.__re

{punit-1.5.2 → punit-1.5.3}/src/punit/filters/FilterManager.py

@@ -11,8 +11,8 @@ from .Filter import Filter
 
 class FilterManager:
 
-    __instance:Optional['FilterManager']|None = None
-    __filters:list[Filter]
+    __instance: Optional['FilterManager'] | None = None
+    __filters: list[Filter]
 
     def __init__(self) -> None:
         self.__filters = list[Filter]()
@@ -29,18 +29,18 @@ class FilterManager:
             FilterManager.__instance = instance
         return instance
 
-    def add(self, pattern:str) -> None:
+    def add(self, pattern: str) -> None:
         self.__filters.append(Filter(pattern))
 
-    def remove(self, pattern:str) -> None:
+    def remove(self, pattern: str) -> None:
         for filter in [e for e in self.__filters]:
             if filter.pattern == pattern:
                 self.__filters.remove(filter)
                 break
 
-    def load(self, filepath:str) -> None:
+    def load(self, filepath: str) -> None:
         # treat as a filepath containing one or more filter patterns
-        lines:list[str] = []
+        lines: list[str] = []
         if filepath == 'stdin':
             ready, _, _ = select.select([sys.stdin], [], [], 5)
             if not ready:
@@ -57,7 +57,7 @@ class FilterManager:
             with open(filepath, 'rb') as f:
                 lines = f.read().decode().splitlines()
         for line in lines:
-            line = line.split('#')[0].strip() # strip comments and prefix/postfix whitespace
+            line = line.split('#')[0].strip()  # strip comments and prefix/postfix whitespace
             if len(line) == 0:
                 # comments and empty lines
                 continue

punit-1.5.3/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]
+    __class_name: str
+    __module_name: str
+    __name: str
+
+    def __init__(self, callable: Union[FunctionType, MethodType, BuiltinFunctionType, BuiltinMethodType, Callable]) -> None:
+        self.__callable = callable
+        self.__class_name = '.'.join(callable.__qualname__.replace(f'{callable.__module__}.', '').split('.')[0:-1])
+        self.__module_name = callable.__module__
+        self.__name = callable.__name__
+
+    @property
+    def class_name(self) -> Optional[str]:
+        return self.__class_name
+
+    @property
+    def filter_name(self) -> str:
+        """
+        The name used for pattern matched "Test Filtering".
+        """
+        return f'{".".join(self.__module_name.split(".")[1:])}/{"" if self.__class_name is None or len(self.__class_name) == 0 else f"{self.__class_name}/"}{self.__name}'
+
+    @property
+    def module_name(self) -> str:
+        return self.__module_name
+
+    @property
+    def name(self) -> str:
+        return self.__name