punit 1.4.8__tar.gz → 1.5.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pUnit
-Version: 1.4.8
+Version: 1.5.2
 Summary: A modernized unit-test framework for Python.
 Author-email: Shaun Wilson <mrshaunwilson@msn.com>
 License: MIT License
@@ -114,7 +114,7 @@ Options:
         Default: '*.py'
     -e, --exclude PATTERN
         Exclude test files matching PATTERN, overriding --include
-        Default: '__*__' (dunder files), '/.*/' (dot-directories)
+        Default: '__*__' (dunders)
     -f, --filter PATTERN|@FILEPATH
         Only execute tests matching PATTERN
         Default: '*'

{punit-1.4.8 → punit-1.5.2}/README.md

@@ -70,7 +70,7 @@ Options:
         Default: '*.py'
     -e, --exclude PATTERN
         Exclude test files matching PATTERN, overriding --include
-        Default: '__*__' (dunder files), '/.*/' (dot-directories)
+        Default: '__*__' (dunders)
     -f, --filter PATTERN|@FILEPATH
         Only execute tests matching PATTERN
         Default: '*'

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pUnit
-Version: 1.4.8
+Version: 1.5.2
 Summary: A modernized unit-test framework for Python.
 Author-email: Shaun Wilson <mrshaunwilson@msn.com>
 License: MIT License
@@ -114,7 +114,7 @@ Options:
         Default: '*.py'
     -e, --exclude PATTERN
         Exclude test files matching PATTERN, overriding --include
-        Default: '__*__' (dunder files), '/.*/' (dot-directories)
+        Default: '__*__' (dunders)
     -f, --filter PATTERN|@FILEPATH
         Only execute tests matching PATTERN
         Default: '*'

{punit-1.4.8 → punit-1.5.2}/src/pUnit.egg-info/SOURCES.txt

@@ -16,6 +16,7 @@ src/punit/runner.py
 src/punit/assertions/__init__.py
 src/punit/assertions/collections.py
 src/punit/assertions/exceptions.py
+src/punit/assertions/numeric.py
 src/punit/assertions/strings.py
 src/punit/discovery/TestModuleDiscovery.py
 src/punit/discovery/__init__.py

punit-1.5.2/src/punit/__init__.py

@@ -0,0 +1,26 @@
+# SPDX-FileCopyrightText: © 2024 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+from .assertions import collections, exceptions, numeric, strings
+from .facts import fact
+from .theories import theory, inlinedata
+from .traits import trait
+
+from .assertions.exceptions import raises
+from .assertions.numeric import approx
+
+
+__version__ = '1.5.2'
+__commit__ = '19ca1ae'
+__all__ = [
+    '__version__', '__commit__',
+    'assertions',
+    'collections',
+    'exceptions', 'raises',
+    'numeric', 'approx',
+    'strings',
+    'fact',
+    'metadata',
+    'theory', 'inlinedata',
+    'trait'
+]

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

@@ -5,6 +5,8 @@ import asyncio
 import os
 import sys
 import time
+from pathlib import Path
+
 from .cli import CommandLineInterface
 from .discovery import TestModuleDiscovery
 from .reports import HtmlReportGenerator, JUnitReportGenerator, JsonReportGenerator
@@ -22,10 +24,12 @@ async def async_main() -> None:
         cli.printVersion()
     os.chdir(cli.workdir)
     if cli.no_pathfix is not True:
-        if os.path.exists('src') and 'src' not in sys.path:
-            sys.path.append('src')
-        if '.' not in sys.path:
-            sys.path.append('src')
+        pathbase = str(Path.cwd())
+        srcbase = os.path.join(pathbase, 'src')
+        if os.path.exists(srcbase) and srcbase not in sys.path:
+            sys.path.append(srcbase)
+        if pathbase not in sys.path:
+            sys.path.append(pathbase)
     testModuleDiscovery = TestModuleDiscovery(
         os.path.join(cli.workdir, cli.testPackageName),
         cli.includePatterns,

{punit-1.4.8 → punit-1.5.2}/src/punit/assertions/__init__.py

@@ -1,11 +1,12 @@
 # SPDX-FileCopyrightText: © 2024 Shaun Wilson
 # SPDX-License-Identifier: MIT
 
-from . import collections, exceptions, strings
+from . import collections, exceptions, numeric, strings
 
 
 __all__ = [
     'collections',
     'exceptions',
+    'numeric',
     'strings'
 ]

{punit-1.4.8 → punit-1.5.2}/src/punit/assertions/collections.py

@@ -4,12 +4,14 @@
 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:
+def are_same(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
+
+    Can optionally specify *sort* so that differences in order do not cause failure.
+
+    :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.
@@ -27,44 +29,48 @@ def areSame(actual: Sequence[Any] | set[Any] | dict[Any, Any] | None, expected:
         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)
+                actual = sorted(cast(dict[Any, Any], actual).items(), key=sort_function)
+                expected = sorted(cast(dict[Any, Any], 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()):
+            for pairs in zip(cast(dict[Any, Any], actual).items(), cast(dict[Any, Any], expected).items()):
                 if not areSame(pairs[0], pairs[1]):
-                    return False            
+                    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
+                elif pairs[0] != pairs[1]:
+                    return False
     return True
 
-def hasLength(actual: Sequence[Any] | set[Any] | dict[Any, Any] | None, expected: int | None) -> bool:
+
+def has_length(actual: Sequence[Any] | set[Any] | dict[Any, Any] | None, min: Optional[int] = None, max: Optional[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
+    if actual is None:
+        if ((min is None or min == 0) and (max is None or max == 0)):
+            return True
+        return not ((min is not None and min != 0) or (max is not None or max != 0))
+    else:
+        if ((min is None) and (max is None)):
+            return False
+        len_actual = len(actual)
+        return (min is None or len_actual >= min) and (max is None or len_actual <= max)
+
 
-def isNoneOrEmpty(actual: Sequence[Any] | set[Any] | dict[Any, Any] | None) -> bool:
+def is_none_or_empty(actual: Sequence[Any] | set[Any] | dict[Any, Any] | None) -> bool:
     """
     Check if actual value is None or empty.
 
@@ -74,3 +80,20 @@ def isNoneOrEmpty(actual: Sequence[Any] | set[Any] | dict[Any, Any] | None) -> b
     if actual is None:
         return True
     return len(actual) == 0
+
+
+# DEPRECATIONS
+areSame = are_same
+hasLength = has_length
+isNoneOrEmpty = is_none_or_empty
+
+
+__all__ = [
+    'are_same',
+    'has_length',
+    'is_none_or_empty',
+    # deprecated (do not use):
+    'areSame',
+    'hasLength',
+    'isNoneOrEmpty'
+]

{punit-1.4.8 → punit-1.5.2}/src/punit/assertions/exceptions.py

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: © 2026 Shaun Wilson
+# SPDX-FileCopyrightText: © 2024 Shaun Wilson
 # SPDX-License-Identifier: MIT
 
 from typing import Any, Callable, Generic, Optional, TypeVar, cast, get_args
@@ -8,12 +8,12 @@ TError = TypeVar('TError', bound=Exception)
 
 
 class raises(Generic[TError]):
-    
-    __action:Callable
-    __exact:bool
-    __expect:Optional[TError|type]
 
-    def __init__(self, action:Callable, *, exact:bool = False, expect:Optional[TError|type] = None) -> None:
+    __action: Callable[[], Any]
+    __exact: bool
+    __expect: Optional[TError | type]
+
+    def __init__(self, action: Callable[[], Any], *, exact: bool = False, expect: Optional[TError | type] = None) -> None:
         self.__action = action
         self.__exact = exact
         self.__expect = expect
@@ -28,7 +28,7 @@ class raises(Generic[TError]):
             if self.__exact:
                 return type(ex) is expected
             elif expected is not None:
-                return issubclass(type(ex), cast(Any,expected))
+                return issubclass(type(ex), cast(Any, expected))
         return False