punit 1.4.0__tar.gz → 1.4.4__tar.gz

punit-1.4.4/.scripts/punit

@@ -0,0 +1,9 @@
+#!/usr/bin/env python
+# SPDX-FileCopyrightText: © 2026 Shaun Wilson
+# SPDX-License-Identifier: MIT
+##
+from subprocess import run
+from sys import executable, argv
+from os import _exit
+result = run([executable, "-m", "punit"] + argv[1:], check=False)
+_exit(result.returncode)

{punit-1.4.0/src/pUnit.egg-info → punit-1.4.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pUnit
-Version: 1.4.0
+Version: 1.4.4
 Summary: A modernized unit-test framework for Python.
 Author-email: Shaun Wilson <mrshaunwilson@msn.com>
 License: MIT License
@@ -30,10 +30,7 @@ Project-URL: Homepage, https://github.com/wilson0x4d/punit
 Project-URL: Repository, https://github.com/wilson0x4d/punit.git
 Keywords: test,unittest,unit-test,xUnit,nUnit,pytest
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Intended Audience :: Developers
 Requires-Python: >=3.11

{punit-1.4.0 → punit-1.4.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pUnit"
-version = "1.4.0"
+version = "1.4.4"
 description = "A modernized unit-test framework for Python."
 keywords = ["test", "unittest", "unit-test", "xUnit", "nUnit", "pytest"]
 authors = [
@@ -11,10 +11,7 @@ license = {file = "LICENSE"}
 requires-python = ">=3.11"
 classifiers = [
     "Operating System :: OS Independent",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-    "Programming Language :: Python :: 3.13",
-    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python",
     "Topic :: Software Development :: Libraries :: Python Modules",
     "Intended Audience :: Developers"
 ]

{punit-1.4.0 → punit-1.4.4/src/pUnit.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pUnit
-Version: 1.4.0
+Version: 1.4.4
 Summary: A modernized unit-test framework for Python.
 Author-email: Shaun Wilson <mrshaunwilson@msn.com>
 License: MIT License
@@ -30,10 +30,7 @@ Project-URL: Homepage, https://github.com/wilson0x4d/punit
 Project-URL: Repository, https://github.com/wilson0x4d/punit.git
 Keywords: test,unittest,unit-test,xUnit,nUnit,pytest
 Classifier: Operating System :: OS Independent
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
-Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Intended Audience :: Developers
 Requires-Python: >=3.11

{punit-1.4.0 → punit-1.4.4}/src/punit/__init__.py

@@ -7,8 +7,8 @@ from .theories import *
 from .traits import *
 
 
-__version__ = '1.4.0'
-__commit__ = 'e1fa8f0'
+__version__ = '1.4.4'
+__commit__ = '9f70be4'
 __all__ = [
     '__version__', '__commit__',
     'assertions',

{punit-1.4.0 → punit-1.4.4}/src/punit/__main__.py

@@ -3,6 +3,7 @@
 
 import asyncio
 import os
+import sys
 import time
 from .cli import CommandLineInterface
 from .discovery import TestModuleDiscovery
@@ -13,11 +14,11 @@ from .runner import TestRunner
 async def async_main() -> None:
     ts = time.time()
     cli = CommandLineInterface.parse()
-    if cli.help: # pragma: no cover
+    if cli.help:  # pragma: no cover
         cli.printHelp()
-    elif cli.verbose and not cli.quiet: # pragma: no cover
+    elif cli.verbose and not cli.quiet:  # pragma: no cover
         cli.printSummary()
-    elif not cli.quiet: # pragma: no cover
+    elif not cli.quiet:  # pragma: no cover
         cli.printVersion()
     os.chdir(cli.workdir)
     testModuleDiscovery = TestModuleDiscovery(
@@ -32,11 +33,11 @@ async def async_main() -> None:
     failureCount = 0
     for result in results:
         if not result.isSuccess:
-            failureCount += 1 # pragma: no cover
+            failureCount += 1  # pragma: no cover
     if not cli.quiet:
         print(f'Total: {len(results)}, Failures: {failureCount}, Took: {totalTime:.3f}s')
-    if cli.reportFormat is not None: # pragma: no cover
-        report:str = ''
+    if cli.reportFormat is not None:  # pragma: no cover
+        report: str = ''
         match cli.reportFormat:
             case 'html':
                 report = HtmlReportGenerator().generate(results)
@@ -52,10 +53,20 @@ async def async_main() -> None:
                     file.write(report.encode())
                 print(f'\n("{cli.reportFormat}" report written to: {cli.outputFilename})')
     if failureCount > 0:
-        exit(119) # pragma: no cover
+        sys.stdout.flush()
+        sys.stderr.flush()
+        try:
+            os.fsync(sys.stdout.fileno())
+            os.fsync(sys.stderr.fileno())
+        except (AttributeError, ValueError, OSError):
+            # Pass if the stream doesn't support fsync (e.g. some virtualized environments)
+            pass
+        os._exit(119)  # pragma: no cover
+
 
 def main() -> None:
     asyncio.run(async_main())
 
+
 if (__name__ == '__main__'):
     main()

punit-1.4.4/src/punit/assertions/collections.py

@@ -0,0 +1,76 @@
+# SPDX-FileCopyrightText: © 2024 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+from typing import Any, Callable, Optional, Sequence, cast
+
+
+def areSame(actual: Sequence[Any] | set[Any] | dict[Any, Any] | None, expected: Sequence[Any] | set[Any] | dict[Any, Any] | None, sort: bool = False, sort_function: Optional[Callable[[Any], Any]] = None) -> bool:
+    """
+    Check if two sequences contain the same elements in the same order.
+    
+    :param actual: The sequence to check
+    :param expected: The sequence to compare against
+    :param sort: Sort sequences before performing comparisons.
+    :param sort_function: Custom function to use when sorting.
+    :returns bool: True if the sequences contain the same elements in the same order, False otherwise.
+    """
+    if actual is expected:
+        return True
+    elif actual is None and expected is not None:
+        return False
+    elif actual is not None and expected is None:
+        return False
+    elif actual is not None and expected is not None:
+        if len(actual) != len(expected):
+            return False
+
+        if sort:
+            if isinstance(actual, dict) or isinstance(expected, dict):
+                sort_function = sort_function if sort_function is not None else lambda e: e[0]
+                actual = sorted(cast(dict, actual).items(), key=sort_function)
+                expected = sorted(cast(dict, expected).items(), key=sort_function)
+            else:
+                sort_function = sort_function if sort_function is not None else lambda e: e
+                actual = sorted(actual, key=sort_function)
+                expected = sorted(expected, key=sort_function)
+
+        if isinstance(actual, dict) or isinstance(expected, dict):
+            for pairs in zip(cast(dict, actual).items(), cast(dict, expected).items()):
+                if not areSame(pairs[0], pairs[1]):
+                    return False            
+        else:
+            for pairs in zip(actual, expected):
+                if isinstance(pairs[0], dict) or isinstance(pairs[1], dict):
+                    if not areSame(pairs[0], pairs[1]):
+                        return False            
+                elif pairs[0] != pairs[1]:
+                        return False
+    return True
+
+def hasLength(actual: Sequence[Any] | set[Any] | dict[Any, Any] | None, expected: int | None) -> bool:
+    """
+    Check if actual value has the expected number of elements.
+    
+    :param actual: The actual value to check.
+    :param int|None expected: The expected number of elements
+        
+    :returns bool: True if the sequence has exactly the expected number of elements, False otherwise
+    """
+    if actual is None and (expected is None or expected == 0):
+        return True
+    elif actual is None and (expected is not None and expected != 0):
+        return False
+    elif actual is not None and expected is None:
+        return False
+    return actual is not None and len(actual) == expected
+
+def isNoneOrEmpty(actual: Sequence[Any] | set[Any] | dict[Any, Any] | None) -> bool:
+    """
+    Check if actual value is None or empty.
+
+    :param actual: The actual to check.
+    :returns: True if the value is None or empty, False otherwise.
+    """
+    if actual is None:
+        return True
+    return len(actual) == 0

{punit-1.4.0 → punit-1.4.4}/src/punit/cli.py

@@ -100,7 +100,7 @@ class CommandLineInterface:
                     case _:
                         print(f'Unsupported value "{arg}" for --report argument, aborting.')
                         print(f'(valid values are "json" and "junit")')
-                        exit(4)
+                        os._exit(4)
                 continue
             elif extractOutputFilename:
                 extractOutputFilename = False
@@ -260,7 +260,7 @@ Options:
         suppress any program output.
 """
         )
-            exit(0)
+            os._exit(0)
 
     def printSummary(self) -> None:
         self.printVersion()
@@ -282,10 +282,10 @@ Options:
     def validate(self) -> None:
         if self.__workdir is None or len(self.__workdir.lstrip()) == 0 or self.__workdir.startswith('-'):
             print(f'Invalid working directory specified: {self.__workdir}')
-            exit(1)
+            os._exit(1)
         elif not os.path.isdir(self.__workdir):
             print(f'Working directory does not exist: {self.__workdir}')
-            exit(2)
+            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`

{punit-1.4.0 → punit-1.4.4}/src/punit/filters/FilterManager.py

@@ -45,15 +45,15 @@ class FilterManager:
             ready, _, _ = select.select([sys.stdin], [], [], 5)
             if not ready:
                 print('No data from stdin, aborting.')
-                sys.exit(7)
+                os._exit(7)
             lines = sys.stdin.read().splitlines()
             if len(lines) == 0:
                 print('No filters from stdin, aborting.')
-                sys.exit(6)
+                os._exit(6)
         else:
             if not os.path.exists(filepath):
                 print(f'file missing or not accessible: {filepath}')
-                sys.exit(5)
+                os._exit(5)
             with open(filepath, 'rb') as f:
                 lines = f.read().decode().splitlines()
         for line in lines:

punit-1.4.0/.scripts/punit

@@ -1,8 +0,0 @@
-#!/usr/bin/env python
-# SPDX-FileCopyrightText: © 2026 Shaun Wilson
-# SPDX-License-Identifier: MIT
-##
-from subprocess import run
-from sys import executable, argv, exit
-result = run([ executable, "-m", "punit" ] + argv[1:], check=False)
-exit(result.returncode)

punit-1.4.0/src/punit/assertions/collections.py

@@ -1,76 +0,0 @@
-# SPDX-FileCopyrightText: © 2024 Shaun Wilson
-# SPDX-License-Identifier: MIT
-
-from typing import Any, Callable, Sequence, Optional, cast
-
-
-def areSame(a:Sequence[Any]|list[Any]|dict[Any,Any]|None, b:Sequence[Any]|list[Any]|dict[Any,Any]|None, sort:bool=False, sortFunction:Optional[Callable[[Any], Any]]=None) -> bool:
-    """
-    Check if two sequences contain the same elements in the same order.
-    
-    :param Sequence[Any]|None a: The sequence to check
-    :param Sequence[Any]|None b: The sequence to compare against
-    :param Optional[bool] sort: Sort sequences before performing comparisons.
-    :param Optional[Callable[[Any], Any]] sortFunction: Custom function to use when sorting.
-    :returns bool: True if the sequences contain the same elements in the same order, False otherwise.
-    """
-    if a is b:
-        return True
-    elif a is None and b is not None:
-        return False
-    elif a is not None and b is None:
-        return False
-    elif a is not None and b is not None:
-        if len(a) != len(b):
-            return False
-
-        if sort:
-            if isinstance(a, dict) or isinstance(b, dict):
-                sortFunction = sortFunction if sortFunction is not None else lambda e: e[0]
-                a = sorted(cast(dict,a).items(), key=sortFunction)
-                b = sorted(cast(dict,b).items(), key=sortFunction)
-            else:
-                sortFunction = sortFunction if sortFunction is not None else lambda e: e
-                a = sorted(a, key=sortFunction)
-                b = sorted(b, key=sortFunction)
-
-        if isinstance(a, dict) or isinstance(b, dict):
-            for pairs in zip(cast(dict,a).items(), cast(dict,b).items()):
-                if not areSame(pairs[0], pairs[1]):
-                    return False            
-        else:
-            for pairs in zip(a, b):
-                if isinstance(pairs[0], dict) or isinstance(pairs[1], dict):
-                    if not areSame(pairs[0], pairs[1]):
-                        return False            
-                elif pairs[0] != pairs[1]:
-                        return False
-    return True
-
-def hasLength(sequence:Sequence[Any]|list[Any]|dict[Any,Any]|None, expected:int|None) -> bool:
-    """
-    Check if a sequence has the expected number of elements.
-    
-    :param Sequence[Any]|None sequence: The sequence to check
-    :param int|None expected: The expected number of elements
-        
-    :returns bool: True if the sequence has exactly the expected number of elements, False otherwise
-    """
-    if sequence is None and (expected is None or expected == 0):
-        return True
-    elif sequence is None and (expected is not None and expected != 0):
-        return False
-    elif sequence is not None and expected is None:
-        return False
-    return sequence is not None and len(sequence) == expected
-
-def isNoneOrEmpty(sequence:Sequence[Any]|list[Any]|dict[Any,Any]|None) -> bool:
-    """
-    Check if a sequence is None or empty.
-
-    :param Sequence[Any]|None sequence: The sequence to check
-    :returns bool: True if the sequence is None or empty, False otherwise
-    """
-    if sequence is None:
-        return True
-    return len(sequence) == 0