punit 1.2.19__tar.gz → 1.2.23__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pUnit
-Version: 1.2.19
+Version: 1.2.23
 Summary: A modernized unit-test framework for Python.
 Author-email: Shaun Wilson <mrshaunwilson@msn.com>
 License: MIT License
@@ -110,10 +110,10 @@ Options:
         be locatable as modules in the named package.
         Default: 'tests'
     -i, --include PATTERN
-        Include any tests matching PATTERN
+        Include test files matching PATTERN
         Default: '*.py'
     -e, --exclude PATTERN
-        Exclude any tests matching PATTERN, overriding --include
+        Exclude test files matching PATTERN, overriding --include
         Default: '__*__' (dunder files), '/.*/' (dot-directories)
     -f, --filter PATTERN|@FILEPATH
         Only execute tests matching PATTERN
@@ -178,9 +178,9 @@ class MyTestFixture:
     def verifyCalcErrorCondition(self) -> None:
         from punit.exceptions import raises
         # assert errors are raised, or not
-        def calc_None():
+        def calc_None() -> None:
             self.calc(None)
-        def calc_1()
+        def calc_1() -> None:
             self.calc(1)
         assert raises[Exception](calc_None)
         assert not raises[Exception](calc_1)

{punit-1.2.19 → punit-1.2.23}/README.md

@@ -64,10 +64,10 @@ Options:
         be locatable as modules in the named package.
         Default: 'tests'
     -i, --include PATTERN
-        Include any tests matching PATTERN
+        Include test files matching PATTERN
         Default: '*.py'
     -e, --exclude PATTERN
-        Exclude any tests matching PATTERN, overriding --include
+        Exclude test files matching PATTERN, overriding --include
         Default: '__*__' (dunder files), '/.*/' (dot-directories)
     -f, --filter PATTERN|@FILEPATH
         Only execute tests matching PATTERN
@@ -132,9 +132,9 @@ class MyTestFixture:
     def verifyCalcErrorCondition(self) -> None:
         from punit.exceptions import raises
         # assert errors are raised, or not
-        def calc_None():
+        def calc_None() -> None:
             self.calc(None)
-        def calc_1()
+        def calc_1() -> None:
             self.calc(1)
         assert raises[Exception](calc_None)
         assert not raises[Exception](calc_1)

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pUnit
-Version: 1.2.19
+Version: 1.2.23
 Summary: A modernized unit-test framework for Python.
 Author-email: Shaun Wilson <mrshaunwilson@msn.com>
 License: MIT License
@@ -110,10 +110,10 @@ Options:
         be locatable as modules in the named package.
         Default: 'tests'
     -i, --include PATTERN
-        Include any tests matching PATTERN
+        Include test files matching PATTERN
         Default: '*.py'
     -e, --exclude PATTERN
-        Exclude any tests matching PATTERN, overriding --include
+        Exclude test files matching PATTERN, overriding --include
         Default: '__*__' (dunder files), '/.*/' (dot-directories)
     -f, --filter PATTERN|@FILEPATH
         Only execute tests matching PATTERN
@@ -178,9 +178,9 @@ class MyTestFixture:
     def verifyCalcErrorCondition(self) -> None:
         from punit.exceptions import raises
         # assert errors are raised, or not
-        def calc_None():
+        def calc_None() -> None:
             self.calc(None)
-        def calc_1()
+        def calc_1() -> None:
             self.calc(1)
         assert raises[Exception](calc_None)
         assert not raises[Exception](calc_1)

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

@@ -22,6 +22,9 @@ src/punit/discovery/__init__.py
 src/punit/facts/Fact.py
 src/punit/facts/FactManager.py
 src/punit/facts/__init__.py
+src/punit/filters/Filter.py
+src/punit/filters/FilterManager.py
+src/punit/filters/__init__.py
 src/punit/reports/HtmlReportGenerator.py
 src/punit/reports/JUnitReportGenerator.py
 src/punit/reports/__init__.py

{punit-1.2.19 → punit-1.2.23}/src/punit/TestResult.py

@@ -16,13 +16,15 @@ class TextIOCapture:
         self.output = None
         self.target = target
 
-    def write(self, text:str):
+    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:
@@ -41,7 +43,7 @@ class TestResult:
     __stopTime:float|None
     __testName:str|None
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.__className = None
         self.__exception = None
         self.__fileName = None

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

@@ -7,8 +7,8 @@ from .theories import *
 from .traits import *
 
 
-__version__ = '1.2.19'
-__commit__ = 'af80eb6'
+__version__ = '1.2.23'
+__commit__ = '5327cc9'
 __all__ = [
     '__version__', '__commit__',
     'assertions',

{punit-1.2.19 → punit-1.2.23}/src/punit/__main__.py

@@ -52,7 +52,7 @@ async def async_main() -> None:
     if failureCount > 0:
         exit(119) # pragma: no cover
 
-def main():
+def main() -> None:
     asyncio.run(async_main())
 
 if (__name__ == '__main__'):

{punit-1.2.19 → punit-1.2.23}/src/punit/cli.py

@@ -5,6 +5,7 @@ import os
 import sys
 from typing import Optional
 from . import __version__, __commit__
+from .filters.FilterManager import FilterManager
 from .traits import Trait
 
 
@@ -14,7 +15,6 @@ class CommandLineInterface:
     __excludePatterns:list[str]
     __excludeTraits:list[Trait]
     __failfast:bool
-    __filterPattern:str
     __help:bool
     __includePatterns:list[str]
     __includeTraits:list[Trait]
@@ -26,12 +26,11 @@ class CommandLineInterface:
     __verbose:bool
     __workdir:str|None
 
-    def __init__(self):
+    def __init__(self) -> None:
         self.__aliases = dict[str,str]()
         self.__excludePatterns = []
         self.__excludeTraits = []
         self.__failfast = False
-        self.__filterPattern = '*'
         self.__help = False
         self.__includePatterns = []
         self.__includeTraits = []
@@ -45,7 +44,7 @@ class CommandLineInterface:
 
     def __parse(self, argv:list[str]) -> 'CommandLineInterface':
         aliasName:str|None = None
-        extractFilterPattern:bool = False
+        extractFilter:bool = False
         extractExcludePattern:bool = False
         extractTrait:bool = False
         extractIncludePattern:bool = False
@@ -54,9 +53,9 @@ class CommandLineInterface:
         extractReportFormat:bool = False
         extractOutputFilename:bool = False
         for arg in argv:
-            if extractFilterPattern:
-                self.__filterPattern = arg
-                extractFilterPattern = False
+            if extractFilter:
+                self.__processFilterArg(arg)
+                extractFilter = False
                 continue
             if extractIncludePattern:
                 self.__includePatterns.append(arg)
@@ -113,7 +112,7 @@ class CommandLineInterface:
                 case '-a':
                     extractAliasName = True
                 case '-f' | '--filter':
-                    extractFilterPattern = True
+                    extractFilter = True
                 case '-e' | '--exclude':
                     extractExcludePattern = True
                 case '-z' | '--failfast':
@@ -138,8 +137,18 @@ class CommandLineInterface:
                     extractTrait = True
                 case _:
                     continue
+
+        if len(FilterManager.instance().filters) == 0:
+            FilterManager.instance().add('*')
+
         return self
 
+    def __processFilterArg(self, arg:str) -> None:
+        if arg.startswith('@'):
+            FilterManager.instance().load(arg[1:])
+        else:
+            FilterManager.instance().add(arg)
+
     @property
     def aliases(self) -> dict:
         return self.__aliases
@@ -148,10 +157,6 @@ class CommandLineInterface:
     def failfast(self) -> bool:
         return self.__failfast
 
-    @property
-    def filterPattern(self) -> str:
-        return self.__filterPattern
-
     @property
     def excludePatterns(self) -> list[str]:
         return self.__excludePatterns
@@ -225,10 +230,10 @@ Options:
         be locatable as modules in the named package.
         Default: 'tests'
     -i, --include PATTERN
-        Include any tests matching PATTERN
+        Include test files matching PATTERN
         Default: '*.py'
     -e, --exclude PATTERN
-        Exclude any tests matching PATTERN, overriding --include
+        Exclude test files matching PATTERN, overriding --include
         Default: '__*__' (dunder files), '/.*/' (dot-directories)
     -f, --filter PATTERN|@FILEPATH
         Only execute tests matching PATTERN
@@ -262,21 +267,14 @@ Options:
         print(f'Working Directory:\n\t{self.__workdir}')
         print(f'Fail Fast: \n\t{"Yes" if self.__failfast else "No"}')
         if len(self.__includePatterns) > 0:
-            print('Include Patterns:')
+            print('Include Files:')
             for pattern in self.__includePatterns:
                 print(f'\t{pattern}')
         if len(self.__excludePatterns) > 0:
-            print('Exclude Patterns:')
+            print('Exclude Files:')
             for pattern in self.__excludePatterns:
                 print(f'\t{pattern}')
-        if self.__filterPattern.startswith('@'):
-            print(f'Filter Patterns: (from {self.__filterPattern[1:]})')
-            if not os.path.exists(os.path.realpath(self.__filterPattern[1:])):
-                print(f'\tFILTERS FILE DOES NOT EXIST, ABORTING!')
-                exit(5)
-        else:
-            print('Filter Pattern:')
-            print(f'\t{self.__filterPattern}')
+        FilterManager.instance().print()
 
     def printVersion(self) -> None:
         print(f'pUnit {__version__} ({__commit__})')

{punit-1.2.19 → punit-1.2.23}/src/punit/discovery/TestModuleDiscovery.py

@@ -9,13 +9,13 @@ from ..theories import TheoryManager
 from ..cli import CommandLineInterface
 from ..traits import Trait
 
+
 class TestModuleDiscovery:
 
     __cli:CommandLineInterface
     __excludePatterns:list[re.Pattern]
     __excludeTraits:list[Trait]
     __filenames:list[str]
-    __filterPatterns:list[re.Pattern]
     __includePatterns:list[re.Pattern]
     __includeTraits:list[Trait]
     __workdir:str
@@ -30,7 +30,6 @@ class TestModuleDiscovery:
                         self.__convertPatternToRegex(pattern),
                         re.IGNORECASE))
         self.__filenames = []
-        self.__filterPatterns = self.__buildFilterPatterns(cli.filterPattern)
         self.__includePatterns = []
         self.__excludeTraits = cli.excludeTraits
         self.__includeTraits = cli.includeTraits
@@ -42,25 +41,11 @@ class TestModuleDiscovery:
                         re.IGNORECASE))
         self.__workdir = workdir
 
-    def __buildFilterPatterns(self, input:str) -> list[re.Pattern]:
-        if input.startswith('@'):
-            # treat as a filepath containing one or more filter patterns
-            filepath = os.path.realpath(input[1:])
-            with open(filepath, 'rb') as f:
-                result = list[re.Pattern]()                
-                for line in f.read().decode().splitlines():
-                    if (self.__cli.verbose):
-                        print(f'\t{line}')
-                    result.append(re.compile(self.__convertPatternToRegex(line)))
-                return result
-        else:
-            # treat as a single filter pattern
-            return [re.compile(self.__convertPatternToRegex(input))]
 
     def __convertPatternToRegex(self, pattern:str) -> str:
         result = re.escape(pattern)\
             .replace('\\\\', '/')\
-            .replace('\\*', r'.+')\
+            .replace('\\*', r'.*')\
             .replace('?', '.')
         return result
 
@@ -115,10 +100,8 @@ class TestModuleDiscovery:
         
     def discover(self) -> list[str]:
         FactManager.instance().excludeTraits = self.__excludeTraits
-        FactManager.instance().filterPatterns = self.__filterPatterns
         FactManager.instance().includeTraits = self.__includeTraits
         TheoryManager.instance().excludeTraits = self.__excludeTraits
-        TheoryManager.instance().filterPatterns = self.__filterPatterns
         TheoryManager.instance().includeTraits = self.__includeTraits
         if self.__cli.verbose:
             print(f'.. starting test discovery')

{punit-1.2.19 → punit-1.2.23}/src/punit/discovery/__init__.py

@@ -3,7 +3,6 @@
 
 from .TestModuleDiscovery import TestModuleDiscovery
 
-
 __all__ = [
     'TestModuleDiscovery'
 ]

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

@@ -5,23 +5,22 @@
 import re
 from typing import Callable, Optional
 
-from .Fact import Fact
+from ..filters.FilterManager import FilterManager
 from ..traits.Trait import Trait
+from .Fact import Fact
 
 
 class FactManager:
 
     __excludeTraits:list[Trait]    
-    __filterPatterns:Optional[list[re.Pattern]]
     __instance:Optional['FactManager'] = None
     __includeTraits:list[Trait]
     __modules:dict[str, list[Fact]]
     __traits:dict[Callable, list[Trait]]
     
-    def __init__(self):
+    def __init__(self) -> None:
         if FactManager.__instance is not None:
             raise Exception('Cannot create more than one instance of FactManager') # pragma: no cover
-        self.__filterPatterns = None
         self.__modules = {}
         self.__traits = {}
 
@@ -39,14 +38,6 @@ class FactManager:
     def excludeTraits(self, value:list[Trait]) -> None:
         self.__excludeTraits = value
 
-    @property
-    def filterPatterns(self) -> Optional[list[re.Pattern]]:
-        return self.__filterPatterns
-    
-    @filterPatterns.setter
-    def filterPatterns(self, value:list[re.Pattern]) -> None:
-        self.__filterPatterns = value
-
     @property
     def includeTraits(self) -> list[Trait]:
         return [] if self.__includeTraits is None else self.__includeTraits
@@ -77,13 +68,13 @@ class FactManager:
         return l
 
     def put(self, fact:Fact) -> None:
-        matchesFilterPattern:bool = self.filterPatterns is None
-        if self.filterPatterns is not None and len(self.filterPatterns) > 0:
-            for filterPattern in self.filterPatterns:
-                if len(filterPattern.findall(fact.filterName)) > 0:
-                    matchesFilterPattern = True
-                    break
-        if matchesFilterPattern:
+        filters = FilterManager.instance().filters
+        matches_filter:bool = False
+        for filter in filters:
+            if filter.re.fullmatch(fact.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:

punit-1.2.23/src/punit/filters/Filter.py

@@ -0,0 +1,37 @@
+# SPDX-FileCopyrightText: © 2026 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+import re
+
+
+class Filter:
+
+    __isExclude:bool
+    __pattern:str
+    __re:re.Pattern
+
+    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:
+        if self.__isExclude:
+            pattern = pattern[1:]
+        pattern = re.escape(pattern)\
+            .replace('\\\\', '/')\
+            .replace('\\*', r'.*')\
+            .replace('?', '.')
+        return re.compile(pattern, re.IGNORECASE)
+
+    @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.2.23/src/punit/filters/FilterManager.py

@@ -0,0 +1,70 @@
+# SPDX-FileCopyrightText: © 2026 Shaun Wilson
+# SPDX-License-Identifier: MIT
+
+import os
+import select
+import sys
+from typing import Optional
+
+from .Filter import Filter
+
+
+class FilterManager:
+
+    __instance:Optional['FilterManager']|None = None
+    __filters:list[Filter]
+
+    def __init__(self) -> None:
+        self.__filters = list[Filter]()
+
+    @property
+    def filters(self) -> list[Filter]:
+        return self.__filters
+
+    @staticmethod
+    def instance() -> 'FilterManager':
+        instance = FilterManager.__instance
+        if instance is None:
+            instance = FilterManager()
+            FilterManager.__instance = instance
+        return instance
+
+    def add(self, pattern:str) -> None:
+        self.__filters.append(Filter(pattern))
+
+    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:
+        # treat as a filepath containing one or more filter patterns
+        lines:list[str] = []
+        if filepath == 'stdin':
+            ready, _, _ = select.select([sys.stdin], [], [], 5)
+            if not ready:
+                print('No data from stdin, aborting.')
+                sys.exit(7)
+            lines = sys.stdin.read().splitlines()
+            if len(lines) == 0:
+                print('No filters from stdin, aborting.')
+                sys.exit(6)
+        else:
+            if not os.path.exists(filepath):
+                print(f'file missing or not accessible: {filepath}')
+                sys.exit(5)
+            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
+            if len(line) == 0:
+                # comments and empty lines
+                continue
+            self.__filters.append(Filter(line))
+
+    def print(self) -> None:
+        if len(FilterManager.instance().filters) > 0:
+            print('Filters:')
+            for filter in self.filters:
+                print(f'\t{filter.pattern}')

punit-1.2.23/src/punit/filters/__init__.py

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

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

@@ -5,6 +5,7 @@
 import re
 from typing import Callable, Optional
 
+from ..filters.FilterManager import FilterManager
 from ..traits.Trait import Trait
 from .Theory import Theory
 
@@ -12,17 +13,15 @@ from .Theory import Theory
 class TheoryManager:
 
     __excludeTraits:list[Trait]
-    __filterPatterns:Optional[list[re.Pattern]]
     __includeTraits:list[Trait]
     __instance:Optional['TheoryManager'] = None
     __modules:dict[str, list[Theory]]
     __datas:dict[Callable, list[tuple]]
     __traits:dict[Callable, list[Trait]]
     
-    def __init__(self):
+    def __init__(self) -> None:
         if TheoryManager.__instance is not None:
             raise Exception('Cannot create more than one instance of TheoryManager') # pragma: no cover
-        self.__filterPatterns = None
         self.__modules = {}
         self.__datas = {}
         self.__traits = {}
@@ -41,14 +40,6 @@ class TheoryManager:
     def excludeTraits(self, value:list[Trait]) -> None:
         self.__excludeTraits = value
 
-    @property
-    def filterPatterns(self) -> Optional[list[re.Pattern]]:
-        return self.__filterPatterns
-    
-    @filterPatterns.setter
-    def filterPatterns(self, value:list[re.Pattern]) -> None:
-        self.__filterPatterns = value
-
     @property
     def includeTraits(self) -> list[Trait]:
         return [] if self.__includeTraits is None else self.__includeTraits
@@ -79,13 +70,13 @@ class TheoryManager:
         return l
 
     def put(self, theory:Theory) -> None:
-        matchesFilterPattern:bool = self.filterPatterns is None
-        if self.filterPatterns is not None and len(self.filterPatterns) > 0:
-            for filterPattern in self.filterPatterns:
-                if len(filterPattern.findall(theory.filterName)) > 0:
-                    matchesFilterPattern = True
-                    break
-        if matchesFilterPattern:
+        filters = FilterManager.instance().filters
+        matches_filter:bool = False
+        for filter in filters:
+            if filter.re.fullmatch(theory.filterName) is not None:
+                matches_filter = not filter.isExclude
+                break
+        if matches_filter:
             l = self.get(theory.moduleName)
             d = self.__datas.get(theory.target)
             if d is not None:
@@ -100,7 +91,7 @@ class TheoryManager:
                 l.append(theory)
 
     def withData(self, target:Callable, data:tuple) -> None:
-        # TODO: data acquisition should be deferred until put() since that is where filterPattern
+        # TODO: data acquisition should be deferred until put() since that is where `Filter` logic
         # is applied, but for current implementation `@inlinedata()` is not affected. more advanced
         # data decorators may benefit from deferral (for example, data coming from an API or DB.)
         d = self.__datas.get(target)