hunterMakesPy 0.1.2__py3-none-any.whl → 0.2.0__py3-none-any.whl

hunterMakesPy/pytestForYourUse.py

@@ -1,327 +1,10 @@
 """Pytest tests you can use in your package to test some hunterMakesPy functions.
 
 Each function in this module returns a list of test functions that can be used with `pytest.parametrize`.
-"""
-from collections.abc import Callable, Iterable, Iterator
-from hunterMakesPy import defineConcurrencyLimit, intInnit, oopsieKwargsie
-from typing import Any, NoReturn
-from unittest.mock import Mock, patch
-import pytest
-
-def PytestFor_defineConcurrencyLimit(callableToTest: Callable[..., int] = defineConcurrencyLimit, cpuCount: int = 8) -> list[tuple[str, Callable[[], None]]]:  # noqa: C901
-	"""Return a list of test functions to validate concurrency limit behavior.
-
-	This function provides a comprehensive test suite for validating concurrency limit parsing
-	and computation, checking both valid and invalid input scenarios.
-
-	Parameters
-	----------
-	callableToTest : Callable[[bool | float | int | None, int], int] = defineConcurrencyLimit
-		The function to test, which should accept various input types and return an integer
-		representing the concurrency limit.
-	cpuCount : int = 8
-		The number of CPUs to simulate in the test environment.
-
-	Returns
-	-------
-	listOfTestFunctions : list[tuple[str, Callable[[], None]]]
-		A list of tuples, each containing a string describing the test case and a callable
-		test function that implements the test case.
-
-	Examples
-	--------
-	Run each test on `hunterMakesPy.defineConcurrencyLimit`:
-	```python
-	from hunterMakesPy.pytestForYourUse import PytestFor_defineConcurrencyLimit
-
-	listOfTests = PytestFor_defineConcurrencyLimit()
-	for nameOfTest, callablePytest in listOfTests:
-		callablePytest()
-	```
-
-	Or, run each test on your function that has a compatible signature:
-	```python
-	from hunterMakesPy.pytestForYourUse import PytestFor_defineConcurrencyLimit
-	from packageLocal import functionLocal
-
-	@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_defineConcurrencyLimit(callableToTest=functionLocal))
-	def test_functionLocal(nameOfTest, callablePytest):
-		callablePytest()
-	```
-
-	"""
-	@patch('multiprocessing.cpu_count', return_value=cpuCount)
-	def testDefaults(_mockCpu: Mock) -> None:
-		listOfParameters: list[bool | int | None] = [None, False, 0]
-		for limitParameter in listOfParameters:
-			assert callableToTest(limit=limitParameter, cpuTotal=cpuCount) == cpuCount
-
-	@patch('multiprocessing.cpu_count', return_value=cpuCount)
-	def testDirectIntegers(_mockCpu: Mock) -> None:
-		for limitParameter in [1, 4, 16]:
-			assert callableToTest(limit=limitParameter, cpuTotal=cpuCount) == limitParameter
-
-	@patch('multiprocessing.cpu_count', return_value=cpuCount)
-	def testFractionalFloats(_mockCpu: Mock) -> None:
-		testCases: dict[float, int] = {
-			0.5: cpuCount // 2,
-			0.25: cpuCount // 4,
-			0.75: int(cpuCount * 0.75)
-		}
-		for limit, expected in testCases.items():
-			assert callableToTest(limit=limit, cpuTotal=cpuCount) == expected
-
-	@patch('multiprocessing.cpu_count', return_value=cpuCount)
-	def testMinimumOne(_mockCpu: Mock) -> None:
-		listOfParameters: list[float | int] = [-10, -0.99, 0.1]
-		for limitParameter in listOfParameters:
-			assert callableToTest(limit=limitParameter, cpuTotal=cpuCount) >= 1
-
-	@patch('multiprocessing.cpu_count', return_value=cpuCount)
-	def testBooleanTrue(_mockCpu: Mock) -> None:
-		assert callableToTest(limit=True, cpuTotal=cpuCount) == 1
-		assert callableToTest(limit='True', cpuTotal=cpuCount) == 1  # pyright: ignore[reportArgumentType]
-		assert callableToTest(limit='TRUE', cpuTotal=cpuCount) == 1 # pyright: ignore[reportArgumentType]
-		assert callableToTest(limit=' true ', cpuTotal=cpuCount) == 1 # pyright: ignore[reportArgumentType]
-
-	@patch('multiprocessing.cpu_count', return_value=cpuCount)
-	def testInvalidStrings(_mockCpu: Mock) -> None:
-		for stringInput in ["invalid", "True but not quite", "None of the above"]:
-			with pytest.raises(ValueError, match="must be a number, `True`, `False`, or `None`"):
-				callableToTest(limit=stringInput, cpuTotal=cpuCount) # pyright: ignore[reportArgumentType]
-
-	@patch('multiprocessing.cpu_count', return_value=cpuCount)
-	def testStringNumbers(_mockCpu: Mock) -> None:
-		testCases: list[tuple[str, int]] = [
-			("1.51", 2),
-			("-2.51", 5),
-			("4", 4),
-			("0.5", 4),
-			("-0.25", 6),
-		]
-		for stringNumber, expectedLimit in testCases:
-			assert callableToTest(limit=stringNumber, cpuTotal=cpuCount) == expectedLimit # pyright: ignore[reportArgumentType]
-
-	return [
-		('testDefaults', testDefaults),
-		('testDirectIntegers', testDirectIntegers),
-		('testFractionalFloats', testFractionalFloats),
-		('testMinimumOne', testMinimumOne),
-		('testBooleanTrue', testBooleanTrue),
-		('testInvalidStrings', testInvalidStrings),
-		('testStringNumbers', testStringNumbers)
-	]
-
-def PytestFor_intInnit(callableToTest: Callable[[Iterable[int], str | None, type[Any] | None], list[int]] = intInnit) -> list[tuple[str, Callable[[], None]]]:  # noqa: C901
-	"""Return a list of test functions to validate integer initialization behavior.
-
-	This function provides a comprehensive test suite for validating integer parsing
-	and initialization, checking both valid and invalid input scenarios.
-
-	Parameters
-	----------
-	callableToTest : Callable[[Iterable[int], str | None, type[Any] | None], list[int]] = intInnit
-		The function to test. Should accept a sequence of integer-compatible values,
-		an optional parameter name string, and an optional parameter type.
-		Returns a list of validated integers.
-
-	Returns
-	-------
-	listOfTestFunctions : list[tuple[str, Callable[[], None]]]
-		A list of tuples containing a string describing the test case and a callable
-		test function implementing the test case.
-
-	Examples
-	--------
-	Run tests on `hunterMakesPy.intInnit`:
-	```python
-	from hunterMakesPy.pytestForYourUse import PytestFor_intInnit
-
-	listOfTests = PytestFor_intInnit()
-	for nameOfTest, callablePytest in listOfTests:
-		callablePytest()
-	```
-
-	Run tests on your compatible function:
-	```python
-	from hunterMakesPy.pytestForYourUse import PytestFor_intInnit
-	from packageLocal import functionLocal
-
-	@pytest.mark.parametrize("nameOfTest,callablePytest",
-		PytestFor_intInnit(callableToTest=functionLocal))
-	def test_functionLocal(nameOfTest, callablePytest):
-		callablePytest()
-	```
-
-	"""
-	def testHandlesValidIntegers() -> None:
-		assert callableToTest([2, 3, 5, 8], 'test', None) == [2, 3, 5, 8]
-		assert callableToTest([13.0, 21.0, 34.0], 'test', None) == [13, 21, 34] # pyright: ignore[reportArgumentType]
-		assert callableToTest(['55', '89', '144'], 'test', None) == [55, 89, 144] # pyright: ignore[reportArgumentType]
-		assert callableToTest([' 233 ', '377', '-610'], 'test', None) == [233, 377, -610] # pyright: ignore[reportArgumentType]
-
-	def testRejectsNonWholeNumbers() -> None:
-		listInvalidNumbers: list[float] = [13.7, 21.5, 34.8, -55.9]
-		for invalidNumber in listInvalidNumbers:
-			with pytest.raises(ValueError):
-				callableToTest([invalidNumber], 'test', None) # pyright: ignore[reportArgumentType]
-
-	def testRejectsBooleans() -> None:
-		with pytest.raises(TypeError):
-			callableToTest([True, False], 'test', None)
 
-	def testRejectsInvalidStrings() -> None:
-		for invalidString in ['NW', '', ' ', 'SE.SW']:
-			with pytest.raises(ValueError):
-				callableToTest([invalidString], 'test', None) # pyright: ignore[reportArgumentType]
-
-	def testRejectsEmptyList() -> None:
-		with pytest.raises(ValueError):
-			callableToTest([], 'test', None)
-
-	def testHandlesMixedValidTypes() -> None:
-		assert callableToTest([13, '21', 34.0], 'test', None) == [13, 21, 34] # pyright: ignore[reportArgumentType]
-
-	def testHandlesBytes() -> None:
-		validCases: list[tuple[list[bytes], str, list[int]]] = [
-			([b'123'], '123', [123]),
-		]
-		for inputData, testName, expected in validCases:
-			assert callableToTest(inputData, testName, None) == expected # pyright: ignore[reportArgumentType]
-
-		extendedCases: list[tuple[list[bytes], str, list[int]]] = [
-			([b'123456789'], '123456789', [123456789]),
-		]
-		for inputData, testName, expected in extendedCases:
-			assert callableToTest(inputData, testName, None) == expected # pyright: ignore[reportArgumentType]
-
-		invalidCases: list[list[bytes]] = [[b'\x00']]
-		for inputData in invalidCases:
-			with pytest.raises(ValueError):
-				callableToTest(inputData, 'test', None) # pyright: ignore[reportArgumentType]
-
-	def testHandlesMemoryview() -> None:
-		validCases: list[tuple[list[memoryview], str, list[int]]] = [
-			([memoryview(b'123')], '123', [123]),
-		]
-		for inputData, testName, expected in validCases:
-			assert callableToTest(inputData, testName, None) == expected # pyright: ignore[reportArgumentType]
-
-		largeMemoryviewCase: list[memoryview] = [memoryview(b'9999999999')]
-		assert callableToTest(largeMemoryviewCase, 'test', None) == [9999999999] # pyright: ignore[reportArgumentType]
-
-		invalidMemoryviewCases: list[list[memoryview]] = [[memoryview(b'\x00')]]
-		for inputData in invalidMemoryviewCases:
-			with pytest.raises(ValueError):
-				callableToTest(inputData, 'test', None) # pyright: ignore[reportArgumentType]
-
-	def testRejectsMutableSequence() -> None:
-		class MutableList(list[int]):
-			def __iter__(self) -> Iterator[int]:
-				self.append(89)
-				return super().__iter__()
-		with pytest.raises(RuntimeError, match=".*modified during iteration.*"):
-			callableToTest(MutableList([13, 21, 34]), 'test', None)
-
-	def testHandlesComplexIntegers() -> None:
-		testCases: list[tuple[list[complex], list[int]]] = [
-			([13+0j], [13]),
-			([21+0j, 34+0j], [21, 34])
-		]
-		for inputData, expected in testCases:
-			assert callableToTest(inputData, 'test', None) == expected # pyright: ignore[reportArgumentType]
-
-	def testRejectsInvalidComplex() -> None:
-		for invalidComplex in [13+1j, 21+0.5j, 34.5+0j]:
-			with pytest.raises(ValueError):
-				callableToTest([invalidComplex], 'test', None) # pyright: ignore[reportArgumentType]
-
-	return [
-		('testHandlesValidIntegers', testHandlesValidIntegers),
-		('testRejectsNonWholeNumbers', testRejectsNonWholeNumbers),
-		('testRejectsBooleans', testRejectsBooleans),
-		('testRejectsInvalidStrings', testRejectsInvalidStrings),
-		('testRejectsEmptyList', testRejectsEmptyList),
-		('testHandlesMixedValidTypes', testHandlesMixedValidTypes),
-		('testHandlesBytes', testHandlesBytes),
-		('testHandlesMemoryview', testHandlesMemoryview),
-		('testRejectsMutableSequence', testRejectsMutableSequence),
-		('testHandlesComplexIntegers', testHandlesComplexIntegers),
-		('testRejectsInvalidComplex', testRejectsInvalidComplex)
-	]
-
-def PytestFor_oopsieKwargsie(callableToTest: Callable[[str], bool | None | str] = oopsieKwargsie) -> list[tuple[str, Callable[[], None]]]:  # noqa: C901
-	"""Return a list of test functions to validate string-to-boolean/None conversion behavior.
-
-	This function provides a comprehensive test suite for validating string parsing and conversion
-	to boolean or None values, with fallback to the original string when appropriate.
-
-	Parameters
-	----------
-	callableToTest : Callable[[str], bool | None | str] = oopsieKwargsie
-		The function to test, which should accept a string and return either a boolean, None,
-		or the original input.
-
-	Returns
-	-------
-	listOfTestFunctions : list[tuple[str, Callable[[], None]]]
-		A list of tuples, each containing a string describing the test case and a callable
-		test function that implements the test case.
-
-	Examples
-	--------
-	Run each test on `hunterMakesPy.oopsieKwargsie`:
-	```python
-	from hunterMakesPy.pytestForYourUse import PytestFor_oopsieKwargsie
-
-	listOfTests = PytestFor_oopsieKwargsie()
-	for nameOfTest, callablePytest in listOfTests:
-		callablePytest()
-	```
-
-	Or, run each test on your function that has a compatible signature:
-	```python
-	from hunterMakesPy.pytestForYourUse import PytestFor_oopsieKwargsie
-	from packageLocal import functionLocal
-
-	@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_oopsieKwargsie(callableToTest=functionLocal))
-	def test_functionLocal(nameOfTest, callablePytest):
-		callablePytest()
-	```
-
-	"""
-	def testHandlesTrueVariants() -> None:
-		for variantTrue in ['True', 'TRUE', ' true ', 'TrUe']:
-			assert callableToTest(variantTrue) is True
-
-	def testHandlesFalseVariants() -> None:
-		for variantFalse in ['False', 'FALSE', ' false ', 'FaLsE']:
-			assert callableToTest(variantFalse) is False
-
-	def testHandlesNoneVariants() -> None:
-		for variantNone in ['None', 'NONE', ' none ', 'NoNe']:
-			assert callableToTest(variantNone) is None
-
-	def testReturnsOriginalString() -> None:
-		for stringInput in ['hello', '123', 'True story', 'False alarm']:
-			assert callableToTest(stringInput) == stringInput
-
-	def testHandlesNonStringObjects() -> None:
-		class NeverGonnaStringIt:
-			def __str__(self) -> NoReturn:
-				message = "Cannot be stringified"
-				raise TypeError(message)
-
-		assert callableToTest(123) == "123" # pyright: ignore[reportArgumentType]
-
-		neverGonnaStringIt = NeverGonnaStringIt()
-		result = callableToTest(neverGonnaStringIt) # pyright: ignore[reportArgumentType]
-		assert result is neverGonnaStringIt
+Note: These test functions are now in `hunterMakesPy.tests` with all other tests.
+"""
 
-	return [
-		('testHandlesTrueVariants', testHandlesTrueVariants),
-		('testHandlesFalseVariants', testHandlesFalseVariants),
-		('testHandlesNoneVariants', testHandlesNoneVariants),
-		('testReturnsOriginalString', testReturnsOriginalString),
-		('testHandlesNonStringObjects', testHandlesNonStringObjects)
-	]
+from hunterMakesPy.tests.test_parseParameters import (
+	PytestFor_defineConcurrencyLimit as PytestFor_defineConcurrencyLimit, PytestFor_intInnit as PytestFor_intInnit,
+	PytestFor_oopsieKwargsie as PytestFor_oopsieKwargsie)

hunterMakesPy/tests/__init__.py

@@ -0,0 +1,5 @@
+"""Test modules for hunterMakesPy package.
+
+This module contains comprehensive test suites for all major functions and features in the hunterMakesPy package. Tests can be run
+independently or imported into your project.
+"""

{tests → hunterMakesPy/tests}/conftest.py

@@ -5,8 +5,7 @@ import pathlib
 import pytest
 
 # SSOT for test data paths and filenames
-# SSOT for test data paths and filenames
-pathDataSamples = pathlib.Path("tests/dataSamples")
+pathDataSamples = pathlib.Path("hunterMakesPy/tests/dataSamples")
 
 # Fixture to provide a temporary directory for filesystem tests
 @pytest.fixture

{tests → hunterMakesPy/tests}/test_coping.py

@@ -1,7 +1,7 @@
 from hunterMakesPy import PackageSettings, raiseIfNone
 from hunterMakesPy.coping import getIdentifierPackagePACKAGING, getPathPackageINSTALLING
+from hunterMakesPy.tests.conftest import uniformTestFailureMessage
 from pathlib import Path
-from tests.conftest import uniformTestFailureMessage
 import pytest
 
 @pytest.mark.parametrize(

{tests → hunterMakesPy/tests}/test_dataStructures.py

@@ -2,13 +2,17 @@
 from collections.abc import Callable, Iterable, Iterator
 from decimal import Decimal
 from fractions import Fraction
-from hunterMakesPy import autoDecodingRLE, stringItUp, updateExtendPolishDictionaryLists
+from hunterMakesPy import stringItUp, updateExtendPolishDictionaryLists
+from hunterMakesPy.tests.conftest import standardizedEqualTo
 from numpy.typing import NDArray
-from tests.conftest import standardizedEqualTo
 from typing import Any, Literal
 import datetime
 import numpy
 import pytest
+import sys
+
+if sys.version_info < (3, 14):
+	from hunterMakesPy import autoDecodingRLE
 
 class CustomIterable:
 	def __init__(self, items: Iterable[Any]) -> None: self.items = items
@@ -81,7 +85,7 @@ def testStringItUpErrorCases(description: Literal['Memory view'], value_scrapPil
 def testUpdateExtendPolishDictionaryLists(description: str, value_dictionaryLists: dict[str, Any], keywordArguments: dict[str, Any], expected: dict[str, Any] | type[TypeError]) -> None:
 	standardizedEqualTo(expected, updateExtendPolishDictionaryLists, *value_dictionaryLists, **keywordArguments)
 # ruff: noqa: ERA001
-# NOTE one line of code with `standardizedEqualTo` replaced the following ten lines of code.
+# NOTE one line of code with `standardizedEqualTo` replaced the following ten lines of code. Use `standardizedEqualTo`.
 	# if isinstance(expected, type) and issubclass(expected, Exception):
 	#	 with pytest.raises(expected):
 	#		 updateExtendPolishDictionaryLists(*value_dictionaryLists, **keywordArguments)
@@ -94,26 +98,28 @@ def testUpdateExtendPolishDictionaryLists(description: str, value_dictionaryList
 	#		 assert result == expected
 
 # ruff: noqa: RUF005
-@pytest.mark.parametrize("description,value_arrayTarget,expected", [
-	("One range", numpy.array(list(range(50,60))), "[*range(50,60)]"),
-	("Value, range", numpy.array([123]+list(range(71,81))), "[123,*range(71,81)]"),
-	("range, value", numpy.array(list(range(91,97))+[101]), "[*range(91,97),101]"),
-	("Value, range, value", numpy.array([151]+list(range(163,171))+[181]), "[151,*range(163,171),181]"),
-	("Repeat values", numpy.array([191, 191, 191]), "[191]*3"),
-	("Value with repeat", numpy.array([211, 223, 223, 223]), "[211]+[223]*3"),
-	("Range with repeat", numpy.array(list(range(251,257))+[271, 271, 271]), "[*range(251,257)]+[271]*3"),
-	("Value, range, repeat", numpy.array([281]+list(range(291,297))+[307, 307]), "[281,*range(291,297)]+[307]*2"),
-	("repeat, value", numpy.array([313, 313, 313, 331, 331, 349]), "[313]*3+[331]*2+[349]"),
-	("repeat, range", numpy.array([373, 373, 373]+list(range(383,389))), "[373]*3+[*range(383,389)]"),
-	("repeat, range, value", numpy.array(7*[401]+list(range(409,415))+[421]), "[401]*7+[*range(409,415),421]"),
-	("Repeated primes", numpy.array([431, 431, 431, 443, 443, 457]), "[431]*3+[443]*2+[457]"),
-	("Two Ranges", numpy.array(list(range(461,471))+list(range(479,487))), "[*range(461,471),*range(479,487)]"),
-	("2D array primes", numpy.array([[491, 499, 503], [509, 521, 523]]), "[[491,499,503],[509,521,523]]"),
-	("3D array primes", numpy.array([[[541, 547], [557, 563]], [[569, 571], [577, 587]]]), "[[[541,547],[557,563]],[[569,571],[577,587]]]"),
-], ids=lambda x: x if isinstance(x, str) else "")
-def testAutoDecodingRLE(description: str, value_arrayTarget: NDArray[numpy.integer[Any]], expected: str) -> None:
-	"""Test autoDecodingRLE with various input arrays."""
-	standardizedEqualTo(expected, autoDecodingRLE, value_arrayTarget)
+
+if sys.version_info < (3, 14):
+	@pytest.mark.parametrize("description,value_arrayTarget,expected", [
+		("One range", numpy.array(list(range(50,60))), "[*range(50,60)]"),
+		("Value, range", numpy.array([123]+list(range(71,81))), "[123,*range(71,81)]"),
+		("range, value", numpy.array(list(range(91,97))+[101]), "[*range(91,97),101]"),
+		("Value, range, value", numpy.array([151]+list(range(163,171))+[181]), "[151,*range(163,171),181]"),
+		("Repeat values", numpy.array([191, 191, 191]), "[191]*3"),
+		("Value with repeat", numpy.array([211, 223, 223, 223]), "[211]+[223]*3"),
+		("Range with repeat", numpy.array(list(range(251,257))+[271, 271, 271]), "[*range(251,257)]+[271]*3"),
+		("Value, range, repeat", numpy.array([281]+list(range(291,297))+[307, 307]), "[281,*range(291,297)]+[307]*2"),
+		("repeat, value", numpy.array([313, 313, 313, 331, 331, 349]), "[313]*3+[331]*2+[349]"),
+		("repeat, range", numpy.array([373, 373, 373]+list(range(383,389))), "[373]*3+[*range(383,389)]"),
+		("repeat, range, value", numpy.array(7*[401]+list(range(409,415))+[421]), "[401]*7+[*range(409,415),421]"),
+		("Repeated primes", numpy.array([431, 431, 431, 443, 443, 457]), "[431]*3+[443]*2+[457]"),
+		("Two Ranges", numpy.array(list(range(461,471))+list(range(479,487))), "[*range(461,471),*range(479,487)]"),
+		("2D array primes", numpy.array([[491, 499, 503], [509, 521, 523]]), "[[491,499,503],[509,521,523]]"),
+		("3D array primes", numpy.array([[[541, 547], [557, 563]], [[569, 571], [577, 587]]]), "[[[541,547],[557,563]],[[569,571],[577,587]]]"),
+	], ids=lambda x: x if isinstance(x, str) else "")
+	def testAutoDecodingRLE(description: str, value_arrayTarget: NDArray[numpy.integer[Any]], expected: str) -> None:
+		"""Test autoDecodingRLE with various input arrays."""
+		standardizedEqualTo(expected, autoDecodingRLE, value_arrayTarget)
 
 # Helper functions for generating RLE test data
 def generateCartesianMapping(dimensions: tuple[int, int], formula: Callable[[int, int], int]) -> NDArray[Any]:
@@ -222,98 +228,98 @@ def generateAlternatingColumns(dimensions: tuple[int, int], blockSize: int = 1)
 
 	return generateCartesianMapping(dimensions, columnFormula)
 
-# Updated test cases for autoDecodingRLE with more realistic data
-@pytest.mark.parametrize("description,value_arrayTarget", [
-	# Basic test cases with simple patterns
-	("Simple range", numpy.array(list(range(50,60)))),
-
-	# Chessboard patterns
-	("Small chessboard", generateChessboard((8, 8))),
-
-	# Alternating columns - creates patterns with good RLE opportunities
-	("Alternating columns", generateAlternatingColumns((5, 20), 2)),
-
-	# Step pattern - creates horizontal runs
-	("Step pattern", generateStepPattern((6, 30), 3)),
-
-	# Repeating zones - creates horizontal bands
-	("Repeating zones", generateRepeatingZones((40, 40), 8)),
-
-	# Tile pattern - creates complex repeating regions
-	("Tile pattern", generateTilePattern((15, 15), 5)),
-
-	# Signed quadratic function - includes negative values
-	("Signed quadratic", generateSignedQuadraticFunction((10, 10))),
-
-	# Prime modulo matrix - periodic patterns
-	("Prime modulo", generatePrimeModuloMatrix((12, 12), 7)),
-
-	# Wave pattern - smooth gradients
-	("Wave pattern", generateWavePattern((20, 20))),
-
-	# Spiral pattern - complex pattern with good RLE potential
-	("Spiral pattern", generateSpiralPattern((15, 15), 2)),
-], ids=lambda x: x if isinstance(x, str) else "")
-def testAutoDecodingRLEWithRealisticData(description: str, value_arrayTarget: NDArray[numpy.integer[Any]]) -> None:
-	"""Test autoDecodingRLE with more realistic data patterns."""
-	# Here we test the function behavior rather than expected string output
-	resultRLE = autoDecodingRLE(value_arrayTarget)
-
-	# Test that the result is a valid string
-	assert isinstance(resultRLE, str)
-
-	# Test that the result contains the expected syntax elements
-	assert "[" in resultRLE, f"Result should contain list syntax: {resultRLE}"
-	assert "]" in resultRLE, f"Result should contain list syntax: {resultRLE}"
-
-	# Check that the result is more compact than the raw string representation
-	rawStrLength = len(str(value_arrayTarget.tolist()))
-	encodedLength = len(resultRLE)
-	assert encodedLength <= rawStrLength, f"Encoded string ({encodedLength}) should be shorter than raw string ({rawStrLength})"
-
-@pytest.mark.parametrize("description,addSpaces", [
-	("With spaces", True),
-	("Without spaces", False),
-], ids=lambda x: x if isinstance(x, str) else "")
-def testAutoDecodingRLEWithSpaces(description: str, addSpaces: bool) -> None:
-	"""Test that the addSpaces parameter affects the internal comparison logic.
-
-	Note: addSpaces doesn't directly change the output format, it just changes
-	the comparison when measuring the length of the string representation.
-	The feature exists because `ast` inserts spaces in its string representation.
-	"""
-	# Create a pattern that has repeated sequences to trigger the RLE logic
-	arrayTarget = generateRepeatingZones((10, 10), 2)
-
-	# Test both configurations
-	resultWithSpacesFlag = autoDecodingRLE(arrayTarget, assumeAddSpaces=addSpaces)
-	resultNoSpacesFlag = autoDecodingRLE(arrayTarget, assumeAddSpaces=False)
-
-	# When addSpaces=True, the internal length comparisons change
-	# but the actual output format doesn't necessarily differ
-	# Just verify the function runs without errors in both cases
-	assert isinstance(resultWithSpacesFlag, str)
-	assert isinstance(resultNoSpacesFlag, str)
-
-def testAutoDecodingRLELargeCartesianMapping() -> None:
-	"""Test autoDecodingRLE with a large (100x100) cartesian mapping."""
-	dimensions = (100, 100)
-
-	# Generate a large cartesian mapping with a complex pattern
-	def complexFormula(x: int, y: int) -> int:
-		return ((x * 17) % 11 + (y * 13) % 7) % 10
-
-	arrayMapping = generateCartesianMapping(dimensions, complexFormula)
-
-	# Verify the function works with large arrays
-	resultRLE = autoDecodingRLE(arrayMapping)
-
-	# The result should be a valid string representation
-	assert isinstance(resultRLE, str)
-	assert "[" in resultRLE
-	assert "]" in resultRLE
-
-	# The RLE encoding should be more compact than the raw representation
-	rawStrLength = len(str(arrayMapping.tolist()))
-	encodedLength = len(resultRLE)
-	assert encodedLength <= rawStrLength, f"RLE encoded string ({encodedLength}) should be shorter than raw string ({rawStrLength})"
+if sys.version_info < (3, 14):
+	@pytest.mark.parametrize("description,value_arrayTarget", [
+		# Basic test cases with simple patterns
+		("Simple range", numpy.array(list(range(50,60)))),
+
+		# Chessboard patterns
+		("Small chessboard", generateChessboard((8, 8))),
+
+		# Alternating columns - creates patterns with good RLE opportunities
+		("Alternating columns", generateAlternatingColumns((5, 20), 2)),
+
+		# Step pattern - creates horizontal runs
+		("Step pattern", generateStepPattern((6, 30), 3)),
+
+		# Repeating zones - creates horizontal bands
+		("Repeating zones", generateRepeatingZones((40, 40), 8)),
+
+		# Tile pattern - creates complex repeating regions
+		("Tile pattern", generateTilePattern((15, 15), 5)),
+
+		# Signed quadratic function - includes negative values
+		("Signed quadratic", generateSignedQuadraticFunction((10, 10))),
+
+		# Prime modulo matrix - periodic patterns
+		("Prime modulo", generatePrimeModuloMatrix((12, 12), 7)),
+
+		# Wave pattern - smooth gradients
+		("Wave pattern", generateWavePattern((20, 20))),
+
+		# Spiral pattern - complex pattern with good RLE potential
+		("Spiral pattern", generateSpiralPattern((15, 15), 2)),
+	], ids=lambda x: x if isinstance(x, str) else "")
+	def testAutoDecodingRLEWithRealisticData(description: str, value_arrayTarget: NDArray[numpy.integer[Any]]) -> None:
+		"""Test autoDecodingRLE with more realistic data patterns."""
+		# Here we test the function behavior rather than expected string output
+		resultRLE = autoDecodingRLE(value_arrayTarget)
+
+		# Test that the result is a valid string
+		assert isinstance(resultRLE, str)
+
+		# Test that the result contains the expected syntax elements
+		assert "[" in resultRLE, f"Result should contain list syntax: {resultRLE}"
+		assert "]" in resultRLE, f"Result should contain list syntax: {resultRLE}"
+
+		# Check that the result is more compact than the raw string representation
+		rawStrLength = len(str(value_arrayTarget.tolist()))
+		encodedLength = len(resultRLE)
+		assert encodedLength <= rawStrLength, f"Encoded string ({encodedLength}) should be shorter than raw string ({rawStrLength})"
+
+	@pytest.mark.parametrize("description,addSpaces", [
+		("With spaces", True),
+		("Without spaces", False),
+	], ids=lambda x: x if isinstance(x, str) else "")
+	def testAutoDecodingRLEWithSpaces(description: str, addSpaces: bool) -> None:
+		"""Test that the addSpaces parameter affects the internal comparison logic.
+
+		Note: addSpaces doesn't directly change the output format, it just changes
+		the comparison when measuring the length of the string representation.
+		The feature exists because `ast` inserts spaces in its string representation.
+		"""
+		# Create a pattern that has repeated sequences to trigger the RLE logic
+		arrayTarget = generateRepeatingZones((10, 10), 2)
+
+		# Test both configurations
+		resultWithSpacesFlag = autoDecodingRLE(arrayTarget, assumeAddSpaces=addSpaces)
+		resultNoSpacesFlag = autoDecodingRLE(arrayTarget, assumeAddSpaces=False)
+
+		# When addSpaces=True, the internal length comparisons change
+		# but the actual output format doesn't necessarily differ
+		# Just verify the function runs without errors in both cases
+		assert isinstance(resultWithSpacesFlag, str)
+		assert isinstance(resultNoSpacesFlag, str)
+
+	def testAutoDecodingRLELargeCartesianMapping() -> None:
+		"""Test autoDecodingRLE with a large (100x100) cartesian mapping."""
+		dimensions = (100, 100)
+
+		# Generate a large cartesian mapping with a complex pattern
+		def complexFormula(x: int, y: int) -> int:
+			return ((x * 17) % 11 + (y * 13) % 7) % 10
+
+		arrayMapping = generateCartesianMapping(dimensions, complexFormula)
+
+		# Verify the function works with large arrays
+		resultRLE = autoDecodingRLE(arrayMapping)
+
+		# The result should be a valid string representation
+		assert isinstance(resultRLE, str)
+		assert "[" in resultRLE
+		assert "]" in resultRLE
+
+		# The RLE encoding should be more compact than the raw representation
+		rawStrLength = len(str(arrayMapping.tolist()))
+		encodedLength = len(resultRLE)
+		assert encodedLength <= rawStrLength, f"RLE encoded string ({encodedLength}) should be shorter than raw string ({rawStrLength})"

{tests → hunterMakesPy/tests}/test_filesystemToolkit.py

@@ -1,6 +1,6 @@
 # pyright: standard
 from hunterMakesPy import importLogicalPath2Identifier, importPathFilename2Identifier, makeDirsSafely, writeStringToHere
-from tests.conftest import uniformTestFailureMessage
+from hunterMakesPy.tests.conftest import uniformTestFailureMessage
 import io
 import math
 import os
@@ -31,7 +31,10 @@ def testImportLogicalPath2Identifier(moduleName: str, identifier: str, expectedT
 	imported = importLogicalPath2Identifier(moduleName, identifier)
 	assert isinstance(imported, expectedType), uniformTestFailureMessage(expectedType, type(imported), "testImportLogicalPath2Identifier", (moduleName, identifier))
 
-@pytest.mark.parametrize( "source, identifier, expected", [ ("def fibonacciNumber():\n    return 13\n", "fibonacciNumber", 13), ("prime = 17\n", "prime", 17), ] )
+@pytest.mark.parametrize(
+	"source, identifier, expected"
+	, [("def fibonacciNumber():\n    return 13\n", "fibonacciNumber", 13)
+	, ("prime = 17\n", "prime", 17)])
 def testImportPathFilename2Identifier(tmp_path: pathlib.Path, source: str, identifier: str, expected: object) -> None:
 	filePath = tmp_path / "moduleTest.py"
 	filePath.write_text(source)