mapFolding 0.12.3__py3-none-any.whl → 0.13.0__py3-none-any.whl

{tests → mapFolding/tests}/conftest.py

@@ -24,7 +24,7 @@ research domain.
 """
 
 from collections.abc import Callable, Generator, Sequence
-from mapFolding import getLeavesTotal, makeDataContainer, validateListDimensions
+from mapFolding import getLeavesTotal, makeDataContainer, oeis, packageSettings, validateListDimensions
 from mapFolding.oeis import oeisIDsImplemented, settingsOEIS
 from pathlib import Path
 from typing import Any
@@ -34,50 +34,90 @@ import random
 import shutil
 import unittest.mock
 import uuid
+import warnings
+
+# ruff: noqa: S311
 
 # SSOT for test data paths and filenames
-pathDataSamples: Path = Path("tests/dataSamples").absolute()
-pathTmpRoot: Path = pathDataSamples / "tmp"
-pathTmpRoot.mkdir(parents=True, exist_ok=True)
+pathDataSamples: Path = Path(packageSettings.pathPackage, "tests/dataSamples").absolute()
+path_tmpRoot: Path = pathDataSamples / "tmp"
+path_tmpRoot.mkdir(parents=True, exist_ok=True)
 
 # The registrar maintains the register of temp files
 registerOfTemporaryFilesystemObjects: set[Path] = set()
 
-def registrarRecordsTmpObject(path: Path) -> None:
-	"""The registrar adds a tmp file to the register."""
+def registrarRecordsTemporaryFilesystemObject(path: Path) -> None:
+	"""The registrar adds a tmp file to the register.
+
+	Parameters
+	----------
+	path : Path
+		The filesystem path to register for cleanup.
+
+	"""
 	registerOfTemporaryFilesystemObjects.add(path)
 
-def registrarDeletesTmpObjects() -> None:
+def registrarDeletesTemporaryFilesystemObjects() -> None:
 	"""The registrar cleans up tmp files in the register."""
-	for pathTmp in sorted(registerOfTemporaryFilesystemObjects, reverse=True):
-		try:
-			if pathTmp.is_file():
-				pathTmp.unlink(missing_ok=True)
-			elif pathTmp.is_dir():
-				shutil.rmtree(pathTmp, ignore_errors=True)
-		except Exception as ERRORmessage:
-			print(f"Warning: Failed to clean up {pathTmp}: {ERRORmessage}")
+	for path_tmp in sorted(registerOfTemporaryFilesystemObjects, reverse=True):
+		if path_tmp.is_file():
+			path_tmp.unlink(missing_ok=True)
+		elif path_tmp.is_dir():
+			shutil.rmtree(path_tmp, ignore_errors=True)
 	registerOfTemporaryFilesystemObjects.clear()
 
 @pytest.fixture(scope="session", autouse=True)
-def setupTeardownTmpObjects() -> Generator[None, None, None]:
-	"""Auto-fixture to setup test data directories and cleanup after."""
+def setupTeardownTemporaryFilesystemObjects() -> Generator[None, None, None]:
+	"""Auto-fixture to setup test data directories and cleanup after.
+
+	Returns
+	-------
+	contextManager : Generator[None, None, None]
+		Context manager that sets up test directories and ensures cleanup.
+
+	"""
 	pathDataSamples.mkdir(exist_ok=True)
-	pathTmpRoot.mkdir(exist_ok=True)
+	path_tmpRoot.mkdir(exist_ok=True)
 	yield
-	registrarDeletesTmpObjects()
+	registrarDeletesTemporaryFilesystemObjects()
 
 @pytest.fixture
-def pathTmpTesting(request: pytest.FixtureRequest) -> Path:
+def path_tmpTesting(request: pytest.FixtureRequest) -> Path:
+	"""Creates a unique temporary directory for testing.
+
+	Parameters
+	----------
+	request : pytest.FixtureRequest
+		The pytest request object providing test context.
+
+	Returns
+	-------
+	temporaryPath : Path
+		Path to a unique temporary directory that will be cleaned up automatically.
+
+	"""
 	# "Z0Z_" ensures the directory name does not start with a number, which would make it an invalid Python identifier
-	pathTmp: Path = pathTmpRoot / ("Z0Z_" + str(uuid.uuid4().hex))
-	pathTmp.mkdir(parents=True, exist_ok=False)
+	path_tmp: Path = path_tmpRoot / ("Z0Z_" + str(uuid.uuid4().hex))
+	path_tmp.mkdir(parents=True, exist_ok=False)
 
-	registrarRecordsTmpObject(pathTmp)
-	return pathTmp
+	registrarRecordsTemporaryFilesystemObject(path_tmp)
+	return path_tmp
 
 @pytest.fixture
-def pathFilenameTmpTesting(request: pytest.FixtureRequest) -> Path:
+def pathFilename_tmpTesting(request: pytest.FixtureRequest) -> Path:
+	"""Creates a unique temporary file path for testing.
+
+	Parameters
+	----------
+	request : pytest.FixtureRequest
+		The pytest request object, optionally containing `param` for file extension.
+
+	Returns
+	-------
+	temporaryFilePath : Path
+		Path to a unique temporary file that will be cleaned up automatically.
+
+	"""
 	try:
 		extension = request.param
 	except AttributeError:
@@ -88,32 +128,62 @@ def pathFilenameTmpTesting(request: pytest.FixtureRequest) -> Path:
 	subpath = "Z0Z_" + uuidHex[0:-8]
 	filenameStem = "Z0Z_" + uuidHex[-8:None]
 
-	pathFilenameTmp = Path(pathTmpRoot, subpath, filenameStem + extension)
-	pathFilenameTmp.parent.mkdir(parents=True, exist_ok=False)
+	pathFilename_tmp = Path(path_tmpRoot, subpath, filenameStem + extension)
+	pathFilename_tmp.parent.mkdir(parents=True, exist_ok=False)
 
-	registrarRecordsTmpObject(pathFilenameTmp)
-	return pathFilenameTmp
+	registrarRecordsTemporaryFilesystemObject(pathFilename_tmp.parent)
+	return pathFilename_tmp
 
 @pytest.fixture
-def pathCacheTesting(pathTmpTesting: Path) -> Generator[Path, Any, None]:
-	"""Temporarily replace the OEIS cache directory with a test directory."""
-	import mapFolding.oeis as oeis
+def pathCacheTesting(path_tmpTesting: Path) -> Generator[Path, Any, None]:
+	"""Temporarily replace the OEIS cache directory with a test directory.
+
+	Parameters
+	----------
+	pathTmpTesting : Path
+		Temporary directory path from the `pathTmpTesting` fixture.
+
+	Returns
+	-------
+	temporaryCachePath : Generator[Path, Any, None]
+		Context manager that provides the temporary cache path and restores original.
+
+	"""
 	pathCacheOriginal = oeis.pathCache
-	oeis.pathCache = pathTmpTesting
-	yield pathTmpTesting
+	oeis.pathCache = path_tmpTesting
+	yield path_tmpTesting
 	oeis.pathCache = pathCacheOriginal
 
 @pytest.fixture
-def pathFilenameFoldsTotalTesting(pathTmpTesting: Path) -> Path:
-	return pathTmpTesting.joinpath("foldsTotalTest.txt")
+def pathFilenameFoldsTotalTesting(path_tmpTesting: Path) -> Path:
+	"""Creates a temporary file path for folds total testing.
+
+	Parameters
+	----------
+	pathTmpTesting : Path
+		Temporary directory path from the `pathTmpTesting` fixture.
+
+	Returns
+	-------
+	foldsTotalFilePath : Path
+		Path to a temporary file for testing folds total functionality.
+
+	"""
+	return path_tmpTesting.joinpath("foldsTotalTest.txt")
 
 """
 Section: Fixtures"""
 
 @pytest.fixture(autouse=True)
 def setupWarningsAsErrors() -> Generator[None, Any, None]:
-	"""Convert all warnings to errors for all tests."""
-	import warnings
+	"""Convert all warnings to errors for all tests.
+
+	Returns
+	-------
+	contextManager : Generator[None, Any, None]
+		Context manager that configures warnings as errors and restores settings.
+
+	"""
 	warnings.filterwarnings("error")
 	yield
 	warnings.resetwarnings()
@@ -129,6 +199,17 @@ def oneTestCuzTestsOverwritingTests(oeisID_1random: str) -> tuple[int, ...]:
 
 	The returned map shape is guaranteed to be computationally feasible for testing purposes,
 	avoiding cases that would take excessive time to complete during test runs.
+
+	Parameters
+	----------
+	oeisID_1random : str
+		Random OEIS sequence identifier from the `oeisID_1random` fixture.
+
+	Returns
+	-------
+	mapDimensions : tuple[int, ...]
+		Valid map dimensions suitable for testing fold counting operations.
+
 	"""
 	while True:
 		n = random.choice(settingsOEIS[oeisID_1random]['valuesTestValidation'])
@@ -143,8 +224,19 @@ def oneTestCuzTestsOverwritingTests(oeisID_1random: str) -> tuple[int, ...]:
 
 @pytest.fixture
 def mapShapeTestCountFolds(oeisID: str) -> tuple[int, ...]:
-	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestValidation`
-	if `validateListDimensions` approves. Each `listDimensions` is suitable for testing counts."""
+	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestValidation` if `validateListDimensions` approves. Each `listDimensions` is suitable for testing counts.
+
+	Parameters
+	----------
+	oeisID : str
+		OEIS sequence identifier from the `oeisID` fixture.
+
+	Returns
+	-------
+	mapDimensions : tuple[int, ...]
+		Valid map dimensions suitable for testing fold counting operations.
+
+	"""
 	while True:
 		n = random.choice(settingsOEIS[oeisID]['valuesTestValidation'])
 		if n < 2:
@@ -158,9 +250,21 @@ def mapShapeTestCountFolds(oeisID: str) -> tuple[int, ...]:
 
 @pytest.fixture
 def mapShapeTestFunctionality(oeisID_1random: str) -> tuple[int, ...]:
-	"""To test functionality, get one `listDimensions` from `valuesTestValidation` if
-	`validateListDimensions` approves. The algorithm can count the folds of the returned
-	`listDimensions` in a short enough time suitable for testing."""
+	"""To test functionality, get one `listDimensions` from `valuesTestValidation` if `validateListDimensions` approves.
+
+	The algorithm can count the folds of the returned `listDimensions` in a short enough time suitable for testing.
+
+	Parameters
+	----------
+	oeisID_1random : str
+		Random OEIS sequence identifier from the `oeisID_1random` fixture.
+
+	Returns
+	-------
+	mapDimensions : tuple[int, ...]
+		Valid map dimensions that can be processed quickly for functional testing.
+
+	"""
 	while True:
 		n = random.choice(settingsOEIS[oeisID_1random]['valuesTestValidation'])
 		if n < 2:
@@ -174,20 +278,46 @@ def mapShapeTestFunctionality(oeisID_1random: str) -> tuple[int, ...]:
 
 @pytest.fixture
 def mapShapeTestParallelization(oeisID: str) -> tuple[int, ...]:
-	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestParallelization`"""
+	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestParallelization`.
+
+	Parameters
+	----------
+	oeisID : str
+		OEIS sequence identifier from the `oeisID` fixture.
+
+	Returns
+	-------
+	mapDimensions : tuple[int, ...]
+		Map dimensions suitable for testing parallelization features.
+
+	"""
 	n = random.choice(settingsOEIS[oeisID]['valuesTestParallelization'])
 	return settingsOEIS[oeisID]['getMapShape'](n)
 
 @pytest.fixture
 def mockBenchmarkTimer() -> Generator[unittest.mock.MagicMock | unittest.mock.AsyncMock, Any, None]:
-	"""Mock time.perf_counter_ns for consistent benchmark timing."""
+	"""Mock time.perf_counter_ns for consistent benchmark timing.
+
+	Returns
+	-------
+	mockTimer : Generator[unittest.mock.MagicMock | unittest.mock.AsyncMock, Any, None]
+		Mock timer that returns predictable timing values for testing benchmarks.
+
+	"""
 	with unittest.mock.patch('time.perf_counter_ns') as mockTimer:
 		mockTimer.side_effect = [0, 1e9]  # Start and end times for 1 second
 		yield mockTimer
 
 @pytest.fixture
 def mockFoldingFunction() -> Callable[..., Callable[..., None]]:
-	"""Creates a mock function that simulates _countFolds behavior."""
+	"""Creates a mock function that simulates _countFolds behavior.
+
+	Returns
+	-------
+	mockFactory : Callable[..., Callable[..., None]]
+		Factory function that creates mock folding functions with specified behavior.
+
+	"""
 	def make_mock(foldsValue: int, listDimensions: list[int]) -> Callable[..., None]:
 		mock_array = makeDataContainer(2, numpy.int32)
 		mock_array[0] = foldsValue
@@ -196,18 +326,39 @@ def mockFoldingFunction() -> Callable[..., Callable[..., None]]:
 
 		def mock_countFolds(**keywordArguments: Any) -> None:
 			keywordArguments['foldGroups'][:] = mock_array
-			return None
 
 		return mock_countFolds
 	return make_mock
 
 @pytest.fixture(params=oeisIDsImplemented)
 def oeisID(request: pytest.FixtureRequest) -> Any:
+	"""Parametrized fixture providing all implemented OEIS sequence identifiers.
+
+	(AI generated docstring)
+
+	Parameters
+	----------
+	request : pytest.FixtureRequest
+		The pytest request object containing the current parameter value.
+
+	Returns
+	-------
+	sequenceIdentifier : Any
+		OEIS sequence identifier for testing across all implemented sequences.
+
+	"""
 	return request.param
 
 @pytest.fixture
 def oeisID_1random() -> str:
-	"""Return one random valid OEIS ID."""
+	"""Return one random valid OEIS ID.
+
+	Returns
+	-------
+	randomSequenceIdentifier : str
+		Randomly selected OEIS sequence identifier from implemented sequences.
+
+	"""
 	return random.choice(oeisIDsImplemented)
 
 def uniformTestMessage(expected: Any, actual: Any, functionName: str, *arguments: Any) -> str:
@@ -219,13 +370,21 @@ def uniformTestMessage(expected: Any, actual: Any, functionName: str, *arguments
 	test suite.
 
 	Parameters
-		expected: The value or exception type that was expected
-		actual: The value or exception type that was actually received
-		functionName: Name of the function being tested
-		arguments: Arguments that were passed to the function
+	----------
+	expected : Any
+		The value or exception type that was expected.
+	actual : Any
+		The value or exception type that was actually received.
+	functionName : str
+		Name of the function being tested.
+	arguments : Any
+		Arguments that were passed to the function.
 
 	Returns
-		formattedMessage: A formatted string showing the test context and comparison
+	-------
+	formattedMessage : str
+		A formatted string showing the test context and comparison.
+
 	"""
 	return (f"\nTesting: `{functionName}({', '.join(str(parameter) for parameter in arguments)})`\n"
 			f"Expected: {expected}\n"
@@ -243,9 +402,14 @@ def standardizedEqualToCallableReturn(expected: Any, functionTarget: Callable[..
 	return value.
 
 	Parameters
-		expected: Expected return value or exception type
-		functionTarget: The function to test
-		arguments: Arguments to pass to the function
+	----------
+	expected : Any
+		Expected return value or exception type.
+	functionTarget : Callable[..., Any]
+		The function to test.
+	arguments : Any
+		Arguments to pass to the function.
+
 	"""
 	if type(expected) is type[Exception]:
 		messageExpected = expected.__name__
@@ -264,13 +428,18 @@ def standardizedSystemExit(expected: str | int | Sequence[int], functionTarget:
 	"""Template for tests expecting SystemExit.
 
 	Parameters
-		expected: Exit code expectation:
-			- "error": any non-zero exit code
-			- "nonError": specifically zero exit code
-			- int: exact exit code match
-			- Sequence[int]: exit code must be one of these values
-		functionTarget: The function to test
-		arguments: Arguments to pass to the function
+	----------
+	expected : str | int | Sequence[int]
+		Exit code expectation:
+		- "error": any non-zero exit code
+		- "nonError": specifically zero exit code
+		- int: exact exit code match
+		- Sequence[int]: exit code must be one of these values
+	functionTarget : Callable[..., Any]
+		The function to test.
+	arguments : Any
+		Arguments to pass to the function.
+
 	"""
 	with pytest.raises(SystemExit) as exitInfo:
 		functionTarget(*arguments)

{tests → mapFolding/tests}/test_computations.py

@@ -1,5 +1,7 @@
 """Core computational verification and algorithm validation tests.
 
+(AI generated docstring)
+
 This module validates the mathematical correctness of map folding computations and
 serves as the primary testing ground for new computational approaches. It's the most
 important module for users who create custom folding algorithms or modify existing ones.
@@ -26,10 +28,11 @@ which is useful if you're working with the code synthesis features of the packag
 from mapFolding import countFolds, getFoldsTotalKnown, oeisIDfor_n
 from mapFolding.dataBaskets import MapFoldingState
 from mapFolding.oeis import settingsOEIS
-from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2Numba
+from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
+from mapFolding.someAssemblyRequired.makeAllModules import parametersNumbaLight
 from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
+from mapFolding.tests.conftest import registrarRecordsTemporaryFilesystemObject, standardizedEqualToCallableReturn
 from pathlib import Path, PurePosixPath
-from tests.conftest import registrarRecordsTmpObject, standardizedEqualToCallableReturn
 from typing import Literal
 import importlib.util
 import multiprocessing
@@ -42,12 +45,22 @@ if __name__ == '__main__':
 def test_flowControl(mapShapeTestCountFolds: tuple[int, ...], flow: Literal['daoOfMapFolding', 'theorem2', 'theorem2numba']) -> None:
 	"""Validate that different computational flows produce identical results.
 
+	(AI generated docstring)
+
 	This is the primary test for ensuring mathematical consistency across different
 	algorithmic implementations. When adding a new computational approach, include
 	it in the parametrized flow list to verify it produces correct results.
 
 	The test compares the output of each flow against known correct values from
 	OEIS sequences, ensuring that optimization techniques don't compromise accuracy.
+
+	Parameters
+	----------
+	mapShapeTestCountFolds : tuple[int, ...]
+		The map shape dimensions to test fold counting for.
+	flow : Literal['daoOfMapFolding', 'theorem2', 'theorem2numba']
+		The computational flow algorithm to validate.
+
 	"""
 	standardizedEqualToCallableReturn(getFoldsTotalKnown(mapShapeTestCountFolds), countFolds, None, None, None, None, mapShapeTestCountFolds, None, None, flow)
 
@@ -73,10 +86,12 @@ def test_aOFn_calculate_value(oeisID: str) -> None:
 	for n in settingsOEIS[oeisID]['valuesTestValidation']:
 		standardizedEqualToCallableReturn(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
 
-@pytest.mark.parametrize('pathFilenameTmpTesting', ['.py'], indirect=True)
-def test_writeJobNumba(oneTestCuzTestsOverwritingTests: tuple[int, ...], pathFilenameTmpTesting: Path) -> None:
+@pytest.mark.parametrize('pathFilename_tmpTesting', ['.py'], indirect=True)
+def test_writeJobNumba(oneTestCuzTestsOverwritingTests: tuple[int, ...], pathFilename_tmpTesting: Path) -> None:
 	"""Test dynamic code generation and execution for computational modules.
 
+	(AI generated docstring)
+
 	This test validates the package's ability to generate, compile, and execute
 	optimized computational code at runtime. It's essential for users working with
 	the code synthesis features or implementing custom optimization strategies.
@@ -84,31 +99,38 @@ def test_writeJobNumba(oneTestCuzTestsOverwritingTests: tuple[int, ...], pathFil
 	The test creates a complete computational module, executes it, and verifies
 	that the generated code produces mathematically correct results. This pattern
 	can be adapted for testing other dynamically generated computational approaches.
+
+	Parameters
+	----------
+	oneTestCuzTestsOverwritingTests : tuple[int, ...]
+		The map shape dimensions for testing code generation.
+	pathFilename_tmpTesting : Path
+		The temporary file path for generated module testing.
+
 	"""
 	from mapFolding.someAssemblyRequired.makeJobTheorem2Numba import makeJobNumba  # noqa: PLC0415
 	from mapFolding.someAssemblyRequired.toolkitNumba import SpicesJobNumba  # noqa: PLC0415
 	mapShape = oneTestCuzTestsOverwritingTests
-	state = MapFoldingState(mapShape)
-	state = initializeGroupsOfFolds(state)
+	state = initializeGroupsOfFolds(MapFoldingState(mapShape))
 
-	pathFilenameModule = pathFilenameTmpTesting.absolute()
+	pathFilenameModule = pathFilename_tmpTesting.absolute()
 	pathFilenameFoldsTotal = pathFilenameModule.with_suffix('.foldsTotalTesting')
-	registrarRecordsTmpObject(pathFilenameFoldsTotal)
+	registrarRecordsTemporaryFilesystemObject(pathFilenameFoldsTotal)
 
-	jobTest = RecipeJobTheorem2Numba(state
+	jobTest = RecipeJobTheorem2(state
 						, pathModule=PurePosixPath(pathFilenameModule.parent)
 						, moduleIdentifier=pathFilenameModule.stem
 						, pathFilenameFoldsTotal=PurePosixPath(pathFilenameFoldsTotal))
-	spices = SpicesJobNumba(useNumbaProgressBar=False)
+	spices = SpicesJobNumba(useNumbaProgressBar=False, parametersNumba=parametersNumbaLight)
 	makeJobNumba(jobTest, spices)
 
 	Don_Lapre_Road_to_Self_Improvement = importlib.util.spec_from_file_location("__main__", pathFilenameModule)
 	if Don_Lapre_Road_to_Self_Improvement is None:
-		msg = f"Failed to create module specification from {pathFilenameModule}"
-		raise ImportError(msg)
+		message = f"Failed to create module specification from {pathFilenameModule}"
+		raise ImportError(message)
 	if Don_Lapre_Road_to_Self_Improvement.loader is None:
-		msg = f"Failed to get loader for module {pathFilenameModule}"
-		raise ImportError(msg)
+		message = f"Failed to get loader for module {pathFilenameModule}"
+		raise ImportError(message)
 	module = importlib.util.module_from_spec(Don_Lapre_Road_to_Self_Improvement)
 
 	module.__name__ = "__main__"

{tests → mapFolding/tests}/test_filesystem.py

@@ -21,23 +21,20 @@ stores computational results or adding new file formats.
 
 from contextlib import redirect_stdout
 from mapFolding import (
-	getFilenameFoldsTotal, getPathFilenameFoldsTotal, getPathRootJobDEFAULT, saveFoldsTotal,
-	validateListDimensions,
-)
+	getFilenameFoldsTotal, getPathFilenameFoldsTotal, getPathRootJobDEFAULT, saveFoldsTotal, validateListDimensions)
 from pathlib import Path
 import io
 import pytest
 import unittest.mock
 
-def test_saveFoldsTotal_fallback(pathTmpTesting: Path) -> None:
+def test_saveFoldsTotal_fallback(path_tmpTesting: Path) -> None:
 	foldsTotal = 123
-	pathFilename = pathTmpTesting / "foldsTotal.txt"
-	with unittest.mock.patch("pathlib.Path.write_text", side_effect=OSError("Simulated write failure")):
-		with unittest.mock.patch("os.getcwd", return_value=str(pathTmpTesting)):
-			capturedOutput = io.StringIO()
-			with redirect_stdout(capturedOutput):
-				saveFoldsTotal(pathFilename, foldsTotal)
-	fallbackFiles = list(pathTmpTesting.glob("foldsTotalYO_*.txt"))
+	pathFilename = path_tmpTesting / "foldsTotal.txt"
+	with unittest.mock.patch("pathlib.Path.write_text", side_effect=OSError("Simulated write failure")), unittest.mock.patch("os.getcwd", return_value=str(path_tmpTesting)):
+		capturedOutput = io.StringIO()
+		with redirect_stdout(capturedOutput):
+			saveFoldsTotal(pathFilename, foldsTotal)
+	fallbackFiles = list(path_tmpTesting.glob("foldsTotalYO_*.txt"))
 	assert len(fallbackFiles) == 1, "Fallback file was not created upon write failure."
 
 @pytest.mark.parametrize("listDimensions, expectedFilename", [
@@ -64,9 +61,9 @@ def test_getPathFilenameFoldsTotal_relativeFilename(mapShapeTestFunctionality: t
 	assert pathFilenameFoldsTotal.is_absolute(), "Path should be absolute"
 	assert pathFilenameFoldsTotal == getPathRootJobDEFAULT() / relativeFilename, "Relative path should be appended to default job root"
 
-def test_getPathFilenameFoldsTotal_createsDirs(pathTmpTesting: Path, mapShapeTestFunctionality: tuple[int, ...]) -> None:
+def test_getPathFilenameFoldsTotal_createsDirs(path_tmpTesting: Path, mapShapeTestFunctionality: tuple[int, ...]) -> None:
 	"""Test that getPathFilenameFoldsTotal creates necessary directories."""
-	nestedPath = pathTmpTesting / "deep/nested/structure"
+	nestedPath = path_tmpTesting / "deep/nested/structure"
 	pathFilenameFoldsTotal = getPathFilenameFoldsTotal(mapShapeTestFunctionality, nestedPath)
 	assert pathFilenameFoldsTotal.parent.exists(), "Parent directories should be created"
 	assert pathFilenameFoldsTotal.parent.is_dir(), "Created path should be a directory"

{tests → mapFolding/tests}/test_oeis.py

@@ -26,19 +26,14 @@ which is crucial for maintaining package reliability in production environments.
 
 from contextlib import redirect_stdout
 from mapFolding.oeis import (
-	clearOEIScache, getOEISids, getOEISidValues, OEIS_for_n, oeisIDfor_n, oeisIDsImplemented,
-	settingsOEIS, validateOEISid,
-)
-from pathlib import Path
-from tests.conftest import standardizedEqualToCallableReturn, standardizedSystemExit
-from typing import Any, NoReturn
-from urllib.error import URLError
+	clearOEIScache, getOEISids, OEIS_for_n, oeisIDfor_n, oeisIDsImplemented, settingsOEIS, validateOEISid)
+from mapFolding.tests.conftest import standardizedEqualToCallableReturn, standardizedSystemExit
+from typing import Any
 import io
 import pytest
 import random
 import re as regex
 import unittest.mock
-import urllib.request
 
 @pytest.mark.parametrize("badID", ["A999999", "  A999999  ", "A999999extra"])
 def test__validateOEISid_invalid_id(badID: str) -> None:
@@ -56,11 +51,11 @@ def test__validateOEISid_valid_id_case_insensitive(oeisID: str) -> None:
 	standardizedEqualToCallableReturn(oeisID.upper(), validateOEISid, oeisID.swapcase())
 
 parameters_test_aOFn_invalid_n = [
-	(-random.randint(1, 100), "randomNegative"),
+	(-random.randint(1, 100), "randomNegative"),  # noqa: S311
 	("foo", "string"),
 	(1.5, "float")
 ]
-badValues, badValuesIDs = zip(*parameters_test_aOFn_invalid_n)
+badValues, badValuesIDs = zip(*parameters_test_aOFn_invalid_n, strict=True)
 @pytest.mark.parametrize("badN", badValues, ids=badValuesIDs)
 def test_aOFn_invalid_n(oeisID_1random: str, badN: Any) -> None:
 	"""Check that negative or non-integer n raises ValueError."""
@@ -87,15 +82,6 @@ def test_clearOEIScache(mock_unlink: unittest.mock.MagicMock, mock_exists: unitt
 		mock_exists.assert_called_once()
 		mock_unlink.assert_not_called()
 
-# Monkey tests
-# def testNetworkError(monkeypatch: pytest.MonkeyPatch, pathCacheTesting: Path) -> None:
-# 	"""Test network error handling."""
-# 	def mockUrlopen(*args: Any, **kwargs: Any) -> NoReturn:
-# 		raise URLError("Network error")
-
-# 	monkeypatch.setattr(urllib.request, 'urlopen', mockUrlopen)
-# 	standardizedEqualToCallableReturn(URLError, getOEISidValues, next(iter(settingsOEIS)))
-
 # ===== Command Line Interface Tests =====
 def testHelpText() -> None:
 	"""Test that help text is complete and examples are valid."""

{tests → mapFolding/tests}/test_other.py

@@ -29,7 +29,7 @@ from collections.abc import Callable
 from hunterMakesPy import intInnit
 from hunterMakesPy.pytestForYourUse import PytestFor_intInnit, PytestFor_oopsieKwargsie
 from mapFolding import getLeavesTotal, setProcessorLimit, validateListDimensions
-from tests.conftest import standardizedEqualToCallableReturn
+from mapFolding.tests.conftest import standardizedEqualToCallableReturn
 from typing import Any, Literal
 import multiprocessing
 import numba
@@ -60,11 +60,11 @@ import sys
 	([float('nan')], ValueError, ValueError),  # NaN
 	([sys.maxsize, sys.maxsize], [sys.maxsize, sys.maxsize], (sys.maxsize, sys.maxsize)),  # overflow protection
 	(range(3, 7), [3, 4, 5, 6], (3, 4, 5, 6)),  # range sequence type
-	(tuple([3, 5, 7]), [3, 5, 7], (3, 5, 7)),  # tuple sequence type
+	(tuple([3, 5, 7]), [3, 5, 7], (3, 5, 7)),  # tuple sequence type  # noqa: C409
 ])
-def test_listDimensionsAsParameter(listDimensions: None | list[str] | list[int] | list[float] | list[None] | list[bool] | list[list[int]] | list[complex] | range | tuple[int, ...],
-							expected_intInnit: type[ValueError] | list[int] | type[TypeError],
-							expected_validateListDimensions: type[ValueError] | type[NotImplementedError] | tuple[int, ...] | type[TypeError]) -> None:
+def test_listDimensionsAsParameter(listDimensions: None | list[Any] | range | tuple[Any, ...]
+	, expected_intInnit: type[Any] | list[int]
+	, expected_validateListDimensions: type[Any] | tuple[int, ...]) -> None:
 	"""Test both validateListDimensions and getLeavesTotal with the same inputs."""
 	standardizedEqualToCallableReturn(expected_intInnit, intInnit, listDimensions)
 	standardizedEqualToCallableReturn(expected_validateListDimensions, validateListDimensions, listDimensions)
@@ -98,6 +98,6 @@ def testOopsieKwargsie(nameOfTest: str, callablePytest: Callable[[], None]) -> N
 	(0, numba.get_num_threads()),
 	(1, 1),
 ])
-def test_setCPUlimitNumba(CPUlimit: None | float | bool | Literal[4] | Literal[-2] | Literal[0] | Literal[1], expectedLimit: Any | int) -> None:
+def test_setCPUlimitNumba(CPUlimit: Literal[4, -2, 0, 1] | None | float | bool, expectedLimit: Any | int) -> None:
 	numba.set_num_threads(multiprocessing.cpu_count())
 	standardizedEqualToCallableReturn(expectedLimit, setProcessorLimit, CPUlimit, 'numba')