mapFolding 0.8.2__py3-none-any.whl → 0.8.4__py3-none-any.whl

tests/conftest.py

@@ -1,16 +1,16 @@
-from importlib import import_module as importlib_import_module
 from collections.abc import Callable, Generator, Sequence
-from types import ModuleType
-
-import numpy
-from mapFolding.theSSOT import ComputationState, The, getPackageDispatcher
 from mapFolding.beDRY import getLeavesTotal, validateListDimensions, makeDataContainer
 from mapFolding.oeis import oeisIDsImplemented, settingsOEIS
-from mapFolding.someAssemblyRequired import RecipeSynthesizeFlow
+from mapFolding.someAssemblyRequired import importLogicalPath2Callable
 from mapFolding.someAssemblyRequired.synthesizeNumbaFlow import makeNumbaFlow
+from mapFolding.someAssemblyRequired._toolboxContainers import RecipeSynthesizeFlow
+from mapFolding.theSSOT import ComputationState, The, getPackageDispatcher
 from pathlib import Path, PurePosixPath
+from types import ModuleType
 from typing import Any, ContextManager
+import importlib
 import importlib.util
+import numpy
 import pytest
 import random
 import shutil
@@ -18,8 +18,9 @@ import unittest.mock
 import uuid
 
 # SSOT for test data paths and filenames
-pathDataSamples = Path("tests/dataSamples")
+pathDataSamples = Path("tests/dataSamples").absolute()
 pathTmpRoot: Path = pathDataSamples / "tmp"
+pathTmpRoot.mkdir(parents=True, exist_ok=True)
 
 # The registrar maintains the register of temp files
 registerOfTemporaryFilesystemObjects: set[Path] = set()
@@ -100,7 +101,22 @@ def setupWarningsAsErrors() -> Generator[None, Any, None]:
 	warnings.resetwarnings()
 
 @pytest.fixture
-def listDimensionsTestCountFolds(oeisID: str):
+def oneTestCuzTestsOverwritingTests(oeisID_1random: str) -> tuple[int, ...]:
+	"""For each `oeisID_1random` from the `pytest.fixture`, returns `listDimensions` from `valuesTestValidation`
+	if `validateListDimensions` approves. Each `listDimensions` is suitable for testing counts."""
+	while True:
+		n = random.choice(settingsOEIS[oeisID_1random]['valuesTestValidation'])
+		if n < 2:
+			continue
+		listDimensionsCandidate = list(settingsOEIS[oeisID_1random]['getMapShape'](n))
+
+		try:
+			return validateListDimensions(listDimensionsCandidate)
+		except (ValueError, NotImplementedError):
+			pass
+
+@pytest.fixture
+def listDimensionsTestCountFolds(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."""
 	while True:
@@ -115,7 +131,7 @@ def listDimensionsTestCountFolds(oeisID: str):
 			pass
 
 @pytest.fixture
-def mapShapeTestFunctionality(oeisID_1random: str):
+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."""
@@ -159,17 +175,6 @@ def mockFoldingFunction() -> Callable[..., Callable[..., None]]:
 		return mock_countFolds
 	return make_mock
 
-@pytest.fixture
-def mockDispatcher() -> Callable[[Any], ContextManager[Any]]:
-	"""Context manager for mocking dispatcher callable."""
-	def wrapper(mockFunction: Any) -> ContextManager[Any]:
-		dispatcherCallable = getPackageDispatcher()
-		return unittest.mock.patch(
-			f"{dispatcherCallable.__module__}.{dispatcherCallable.__name__}",
-			side_effect=mockFunction
-		)
-	return wrapper
-
 @pytest.fixture(params=oeisIDsImplemented)
 def oeisID(request: pytest.FixtureRequest) -> Any:
 	return request.param
@@ -198,42 +203,42 @@ def useThisDispatcher() -> Generator[Callable[..., None], Any, None]:
 	basecamp.getPackageDispatcher = dispatcherOriginal
 
 def getAlgorithmDispatcher() -> Callable[[ComputationState], ComputationState]:
-	moduleImported: ModuleType = importlib_import_module(The.logicalPathModuleSourceAlgorithm)
-	dispatcherCallable = getattr(moduleImported, The.dispatcherCallable)
+	moduleImported: ModuleType = importlib.import_module(The.logicalPathModuleSourceAlgorithm)
+	dispatcherCallable = getattr(moduleImported, The.sourceCallableDispatcher)
 	return dispatcherCallable
 
 @pytest.fixture
 def useAlgorithmSourceDispatcher(useThisDispatcher: Callable[..., Any]) -> Generator[None, None, None]:
 	"""Temporarily patches getDispatcherCallable to return the algorithm dispatcher."""
-	useThisDispatcher(getAlgorithmDispatcher())
+	useThisDispatcher(importLogicalPath2Callable(The.logicalPathModuleSourceAlgorithm, The.sourceCallableDispatcher))
 	yield
 
 @pytest.fixture
 def syntheticDispatcherFixture(useThisDispatcher: Callable[..., Any], pathTmpTesting: Path) -> Callable[..., Any]:
     """Generate synthetic Numba-optimized dispatcher module and patch the dispatcher"""
     # Configure synthesis flow to use test directory
-    recipeFlow = RecipeSynthesizeFlow(
+    TESTINGrecipeFlow = RecipeSynthesizeFlow(
         pathPackage=PurePosixPath(pathTmpTesting.absolute()),
-        Z0Z_flowLogicalPathRoot=None,
+        logicalPathFlowRoot=None,
         moduleDispatcher="test_dispatcher",
 # Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
         # dispatcherCallable="dispatcherSynthetic",
     )
 
     # Generate optimized module in test directory
-    makeNumbaFlow(recipeFlow)
+    makeNumbaFlow(TESTINGrecipeFlow)
 
     # Import synthesized dispatcher
     importlibSpecificationDispatcher = importlib.util.spec_from_file_location(
-        recipeFlow.moduleDispatcher,
-        Path(recipeFlow.pathFilenameDispatcher),
+        TESTINGrecipeFlow.moduleDispatcher,
+        Path(TESTINGrecipeFlow.pathFilenameDispatcher),
     )
     if importlibSpecificationDispatcher is None or importlibSpecificationDispatcher.loader is None:
         raise ImportError("Failed to load synthetic dispatcher module")
 
     moduleSpecificationDispatcher = importlib.util.module_from_spec(importlibSpecificationDispatcher)
     importlibSpecificationDispatcher.loader.exec_module(moduleSpecificationDispatcher)
-    callableDispatcherSynthetic = getattr(moduleSpecificationDispatcher, recipeFlow.dispatcherCallable)
+    callableDispatcherSynthetic = getattr(moduleSpecificationDispatcher, TESTINGrecipeFlow.callableDispatcher)
 
     # Patch dispatcher and return callable
     useThisDispatcher(callableDispatcherSynthetic)

tests/test_computations.py

@@ -1,53 +1,62 @@
 from mapFolding.basecamp import countFolds
 from mapFolding.filesystem import getPathFilenameFoldsTotal
+from mapFolding.beDRY import validateListDimensions
 from mapFolding.noHomeYet import getFoldsTotalKnown
 from mapFolding.oeis import settingsOEIS, oeisIDfor_n
-# from mapFolding.someAssemblyRequired import writeJobNumba
-from pathlib import Path
+from mapFolding.someAssemblyRequired.synthesizeNumbaJob import makeJobNumba, Z0Z_RecipeJob
+from mapFolding.someAssemblyRequired.transformDataStructures import makeInitializedComputationState
+from pathlib import Path, PurePosixPath
 from tests.conftest import standardizedEqualToCallableReturn, registrarRecordsTmpObject
 from types import ModuleType
 import importlib.util
 import multiprocessing
+import threading
+from copy import deepcopy
 import pytest
 
 if __name__ == '__main__':
 	multiprocessing.set_start_method('spawn')
 
 def test_algorithmSourceParallel(listDimensionsTestParallelization: list[int], useAlgorithmSourceDispatcher: None) -> None:
-    standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestParallelization)), countFolds, listDimensionsTestParallelization, None, 'maximum', None)
+	standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestParallelization)), countFolds, listDimensionsTestParallelization, None, 'maximum', None)
 
 def test_algorithmSourceSequential(listDimensionsTestCountFolds: tuple[int, ...], useAlgorithmSourceDispatcher: None) -> None:
-    standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestCountFolds)), countFolds, listDimensionsTestCountFolds)
+	standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestCountFolds)), countFolds, listDimensionsTestCountFolds)
 
 def test_aOFn_calculate_value(oeisID: str) -> None:
-    for n in settingsOEIS[oeisID]['valuesTestValidation']:
-        standardizedEqualToCallableReturn(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
+	for n in settingsOEIS[oeisID]['valuesTestValidation']:
+		standardizedEqualToCallableReturn(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
 
 def test_syntheticParallel(syntheticDispatcherFixture: None, listDimensionsTestParallelization: list[int]):
-    standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestParallelization)), countFolds, listDimensionsTestParallelization, None, 'maximum')
+	standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestParallelization)), countFolds, listDimensionsTestParallelization, None, 'maximum')
 
 def test_syntheticSequential(syntheticDispatcherFixture: None, listDimensionsTestCountFolds: list[int]) -> None:
-    standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestCountFolds)), countFolds, listDimensionsTestCountFolds)
-
-# @pytest.mark.parametrize('pathFilenameTmpTesting', ['.py'], indirect=True)
-# def test_writeJobNumba(listDimensionsTestCountFolds: list[int], pathFilenameTmpTesting: Path) -> None:
-#     from mapFolding.syntheticModules import numbaCount
-#     algorithmSourceHARDCODED: ModuleType = numbaCount
-#     algorithmSource = algorithmSourceHARDCODED
-#     callableTargetHARDCODED = 'countSequential'
-#     callableTarget = callableTargetHARDCODED
-#     pathFilenameModule = writeJobNumba(listDimensionsTestCountFolds, algorithmSource, callableTarget, pathFilenameWriteJob=pathFilenameTmpTesting.absolute())
-
-#     Don_Lapre_Road_to_Self_Improvement = importlib.util.spec_from_file_location("__main__", pathFilenameModule)
-#     if Don_Lapre_Road_to_Self_Improvement is None:
-#         raise ImportError(f"Failed to create module specification from {pathFilenameModule}")
-#     if Don_Lapre_Road_to_Self_Improvement.loader is None:
-#         raise ImportError(f"Failed to get loader for module {pathFilenameModule}")
-#     module = importlib.util.module_from_spec(Don_Lapre_Road_to_Self_Improvement)
-
-#     module.__name__ = "__main__"
-#     Don_Lapre_Road_to_Self_Improvement.loader.exec_module(module)
-
-#     pathFilenameFoldsTotal = getPathFilenameFoldsTotal(listDimensionsTestCountFolds)
-#     registrarRecordsTmpObject(pathFilenameFoldsTotal)
-#     standardizedEqualToCallableReturn(str(getFoldsTotalKnown(tuple(listDimensionsTestCountFolds))), pathFilenameFoldsTotal.read_text().strip)
+	standardizedEqualToCallableReturn(getFoldsTotalKnown(tuple(listDimensionsTestCountFolds)), countFolds, listDimensionsTestCountFolds)
+
+@pytest.mark.parametrize('pathFilenameTmpTesting', ['.py'], indirect=True)
+def test_writeJobNumba(oneTestCuzTestsOverwritingTests: list[int], pathFilenameTmpTesting: Path) -> None:
+	mapShape = validateListDimensions(oneTestCuzTestsOverwritingTests)
+	state = makeInitializedComputationState(mapShape)
+
+	pathFilenameModule = pathFilenameTmpTesting.absolute()
+	pathFilenameFoldsTotal = pathFilenameModule.with_suffix('.foldsTotalTesting')
+	registrarRecordsTmpObject(pathFilenameFoldsTotal)
+
+	jobTest = Z0Z_RecipeJob(state
+						, pathModule=PurePosixPath(pathFilenameModule.parent)
+						, moduleIdentifier=pathFilenameModule.stem
+						, pathFilenameFoldsTotal=PurePosixPath(pathFilenameFoldsTotal))
+
+	makeJobNumba(jobTest)
+
+	Don_Lapre_Road_to_Self_Improvement = importlib.util.spec_from_file_location("__main__", pathFilenameModule)
+	if Don_Lapre_Road_to_Self_Improvement is None:
+		raise ImportError(f"Failed to create module specification from {pathFilenameModule}")
+	if Don_Lapre_Road_to_Self_Improvement.loader is None:
+		raise ImportError(f"Failed to get loader for module {pathFilenameModule}")
+	module = importlib.util.module_from_spec(Don_Lapre_Road_to_Self_Improvement)
+
+	module.__name__ = "__main__"
+	Don_Lapre_Road_to_Self_Improvement.loader.exec_module(module)
+
+	standardizedEqualToCallableReturn(str(getFoldsTotalKnown(mapShape)), pathFilenameFoldsTotal.read_text().strip)

tests/test_filesystem.py

@@ -1,7 +1,7 @@
 from contextlib import redirect_stdout
 from mapFolding.filesystem import getFilenameFoldsTotal, getPathFilenameFoldsTotal, saveFoldsTotal
 from mapFolding.beDRY import validateListDimensions
-from mapFolding.theSSOT import getPathJobRootDEFAULT
+from mapFolding.filesystem import getPathRootJobDEFAULT
 from pathlib import Path
 import io
 import pytest
@@ -33,14 +33,14 @@ def test_getPathFilenameFoldsTotal_defaultPath(mapShapeTestFunctionality: tuple[
     pathFilenameFoldsTotal = getPathFilenameFoldsTotal(mapShapeTestFunctionality)
     assert pathFilenameFoldsTotal.is_absolute(), "Path should be absolute"
     assert pathFilenameFoldsTotal.name == getFilenameFoldsTotal(mapShapeTestFunctionality), "Filename should match getFilenameFoldsTotal output"
-    assert pathFilenameFoldsTotal.parent == getPathJobRootDEFAULT(), "Parent directory should match default job root"
+    assert pathFilenameFoldsTotal.parent == getPathRootJobDEFAULT(), "Parent directory should match default job root"
 
 def test_getPathFilenameFoldsTotal_relativeFilename(mapShapeTestFunctionality: tuple[int, ...]) -> None:
     """Test getPathFilenameFoldsTotal with relative filename."""
     relativeFilename = Path("custom/path/test.foldsTotal")
     pathFilenameFoldsTotal = getPathFilenameFoldsTotal(mapShapeTestFunctionality, relativeFilename)
     assert pathFilenameFoldsTotal.is_absolute(), "Path should be absolute"
-    assert pathFilenameFoldsTotal == getPathJobRootDEFAULT() / relativeFilename, "Relative path should be appended to default job root"
+    assert pathFilenameFoldsTotal == getPathRootJobDEFAULT() / relativeFilename, "Relative path should be appended to default job root"
 
 def test_getPathFilenameFoldsTotal_createsDirs(pathTmpTesting: Path, mapShapeTestFunctionality: tuple[int, ...]) -> None:
     """Test that getPathFilenameFoldsTotal creates necessary directories."""

tests/test_other.py

@@ -5,6 +5,7 @@ from tests.conftest import standardizedEqualToCallableReturn
 from typing import Any, Literal
 from Z0Z_tools import intInnit
 from Z0Z_tools.pytestForYourUse import PytestFor_intInnit, PytestFor_oopsieKwargsie
+import multiprocessing
 import numba
 import pytest
 import sys
@@ -78,6 +79,6 @@ def testOopsieKwargsie(nameOfTest: str, callablePytest: Callable[[], None]) -> N
 	(0, numba.get_num_threads()),
 	(1, 1),
 ])
-def test_setCPUlimit(CPUlimit: None | float | bool | Literal[4] | Literal[-2] | Literal[0] | Literal[1], expectedLimit: Any | int) -> None:
-	if The.concurrencyPackage == 'numba':
-		standardizedEqualToCallableReturn(expectedLimit, setCPUlimit, CPUlimit)
+def test_setCPUlimitNumba(CPUlimit: None | float | bool | Literal[4] | Literal[-2] | Literal[0] | Literal[1], expectedLimit: Any | int) -> None:
+	numba.set_num_threads(multiprocessing.cpu_count())
+	standardizedEqualToCallableReturn(expectedLimit, setCPUlimit, CPUlimit, 'numba')