mapFolding 0.8.3__py3-none-any.whl → 0.8.5__py3-none-any.whl

{mapfolding-0.8.3.dist-info → mapfolding-0.8.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.8.3
+Version: 0.8.5
 Summary: Map folding algorithm with code transformation framework for optimizing numerical computations
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -35,6 +35,7 @@ Requires-Dist: more_itertools
 Requires-Dist: numba_progress
 Requires-Dist: numba
 Requires-Dist: numpy
+Requires-Dist: platformdirs
 Requires-Dist: python_minifier
 Requires-Dist: tomli
 Requires-Dist: Z0Z_tools
@@ -45,6 +46,7 @@ Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pytest-env; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
 Requires-Dist: pyupgrade; extra == "testing"
+Requires-Dist: ruff; extra == "testing"
 Dynamic: license-file
 
 # mapFolding: Algorithms for enumerating distinct map/stamp folding patterns 🗺️
@@ -131,7 +133,7 @@ The package provides a sophisticated transformation framework that bridges the g
   - Study the functional state-transformation approach in `theDao.py` with clear, isolated functions
   - Explore the semantic decomposition in `reference/flattened.py` to understand algorithm sections
 
-- **Code Transformation Pipeline**:
+- **Code Transformation Assembly-line**:
   - **AST Manipulation**: Analyzes and transforms the algorithm's abstract syntax tree
   - **Dataclass "Shattering"**: Decomposes complex state objects into primitive components
   - **Optimization Applications**: Applies domain-specific optimizations for numerical computation

mapfolding-0.8.5.dist-info/RECORD

@@ -0,0 +1,48 @@
+mapFolding/__init__.py,sha256=LBgk-iW95pzqkFGY8PbcnU0oHy0AXwJGo18mM0g8wEw,2227
+mapFolding/basecamp.py,sha256=-__EJ2to84ssS4Fm0CAuQjRnghI9VA4cXZoWGYud1r0,4782
+mapFolding/beDRY.py,sha256=2GPO4A8XcxoEJXB_3sro4ZFQ5gcU7ywc1-c8HLEvEv0,15280
+mapFolding/noHomeYet.py,sha256=UKZeWlyn0SKlF9dhYoud7E6gWXpiSEekZOOoJp88WeI,1362
+mapFolding/oeis.py,sha256=EzEnbRi_4qt8Na2tiMcvL23FXpcJEkXTwuXDYDFH_XI,12631
+mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/theDao.py,sha256=MVopt1LzhdIQYA97SEoq9bdzct6hbK0lEyPxBAAlVTc,9934
+mapFolding/theSSOT.py,sha256=i3R_G702U7VQOil61ky60JGGsSEOk_x1555rg8yI0Tc,11978
+mapFolding/toolboxFilesystem.py,sha256=WoqRjXqTXy5GYNmbfzWtzv1uufm7vYcgT4zJ9ffhRYY,9982
+mapFolding/reference/__init__.py,sha256=UIEU8BJR_YDzjFQcLel3XtHzOCJiOUGlGiWzOzbvhik,2206
+mapFolding/reference/flattened.py,sha256=QK1xG9SllqCoi68e86Hyl9d9ATUAAFNpTQI-3zmcp5I,16072
+mapFolding/reference/hunterNumba.py,sha256=iLfyqwGdAh6c5GbapnKsWhAsNsR3O-fyGGHAdohluLw,7258
+mapFolding/reference/irvineJavaPort.py,sha256=UEfIX4QbPLl5jnyfYIyX5YRR3_rYvPUikK8jLehsFko,4076
+mapFolding/reference/jaxCount.py,sha256=TuDNKOnyhQfuixKmIxO9Algv7dvy7KMGhgsV3h96FGE,14853
+mapFolding/reference/lunnanNumpy.py,sha256=mMgrgbrBpe4nmo72ThEI-MGH0OwEHmfMPczSXHp2qKo,4357
+mapFolding/reference/lunnanWhile.py,sha256=ZL8GAQtPs5nJZSgoDl5USrLSS_zs03y98y1Z9E4jOmQ,3799
+mapFolding/reference/rotatedEntryPoint.py,sha256=5ughpKUT2JQhoAKgoDUdYNjgWQYPGV8v-7dWEAdDmfE,10274
+mapFolding/reference/total_countPlus1vsPlusN.py,sha256=yJZAVLVdoXqHag2_N6_6CT-Q6HXBgRro-eny93-Rlpw,9307
+mapFolding/reference/jobsCompleted/__init__.py,sha256=TU93ZGUW1xEkT6d9mQFn_rp5DvRy0ZslEB2Q6MF5ZDc,2596
+mapFolding/reference/jobsCompleted/[2x19]/p2x19.py,sha256=_tvYtfzMWVo2VtUbIAieoscb4N8FFflgTdW4-ljBUuA,19626
+mapFolding/reference/jobsCompleted/p2x19/p2x19.py,sha256=eZEw4Me4ocTt6VXoK2-Sbd5SowZtxRIbN9dZmc7OCVg,6395
+mapFolding/someAssemblyRequired/__init__.py,sha256=c2GFI2HSId2_R_aoJWBID-P9AMF3zoHJzOc10XS6DHc,2669
+mapFolding/someAssemblyRequired/_theTypes.py,sha256=SG82WTtQy83BmInlHZHY8Nh3Kp161NcEFSA6-UU5wuE,4623
+mapFolding/someAssemblyRequired/_tool_Make.py,sha256=8ezrMDAdUY6m1raFp-G8vNXrHEr8IGfnZJ-aMVKzGf0,7092
+mapFolding/someAssemblyRequired/_tool_Then.py,sha256=QxuoBqj4iOeKWITjV3DcV8c25fLx3Q6mhUORD7-mCzc,2758
+mapFolding/someAssemblyRequired/_toolboxAntecedents.py,sha256=GEAuniYRj6yOtrJO_6sGZMzsVARdejts8NXhR_0np_c,21914
+mapFolding/someAssemblyRequired/_toolboxContainers.py,sha256=iPLZbFcGB6dKtX3WkopnM-2OtMcVuxXQT46iFhzpdfY,17815
+mapFolding/someAssemblyRequired/_toolboxPython.py,sha256=za30092eT00tj5ctqUCRrEuq5DGeJZN-vV9T4Dro-1w,3483
+mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=9RPU6vK_eUg64GtVFI_nZnvUryXw8gfHJs9NyDYHIvg,2745
+mapFolding/someAssemblyRequired/newInliner.py,sha256=Tm9PSzt66oIXPVrN9VdQwEYBba2iEOF5X3aEsOOF-FE,946
+mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=0L5ccqBusof6MzKatKnpUmFUNkAtbapzl_Fxmofi4DE,8684
+mapFolding/someAssemblyRequired/toolboxNumba.py,sha256=rluEmsSJOQCl2L6LlJzIc3AfeRxU6cp-sCf-rQFW-og,22613
+mapFolding/someAssemblyRequired/transformationTools.py,sha256=iIvRxSL45qTyl0d0ztHa9BP1MrOikfXE4HBqLlNMENc,20081
+mapFolding/syntheticModules/__init__.py,sha256=evVFqhCGa-WZKDiLcnQWjs-Bj34eRnfSLqz_d7dFYZY,83
+mapFolding/syntheticModules/numbaCount_doTheNeedful.py,sha256=3thXThbv2Xo0t_cRGzMbHPFXTBmLClmKejR_Ibu_jOo,15697
+mapfolding-0.8.5.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/conftest.py,sha256=LfogHLu7PULSECwhLQgGCgqSvDMBc5b9RGWBls3YBrM,11364
+tests/test_computations.py,sha256=XjCej6M6lesfKB_ulWq3O-ryXBsJuuwnJ6_XjKOvgDY,3552
+tests/test_filesystem.py,sha256=YEHNU6tUCTj9C65cKs3ETgt3OZTGVnNjxgu4aH6C9uU,3164
+tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
+tests/test_other.py,sha256=O05PFAK70Skf-k99Wcg4ASLpMpBH-WkELtk6MnynDx0,4293
+tests/test_tasks.py,sha256=S-6PNfM__Npw0zVojgzn5M-6ODBKDyRH5ccMTqQF9C4,2865
+mapfolding-0.8.5.dist-info/METADATA,sha256=vrusTb9uu8FQ3UksfFkVZ3txtYPNufYa3db-Rk6H1y0,9359
+mapfolding-0.8.5.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+mapfolding-0.8.5.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapfolding-0.8.5.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapfolding-0.8.5.dist-info/RECORD,,

{mapfolding-0.8.3.dist-info → mapfolding-0.8.5.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (77.0.3)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tests/conftest.py

@@ -1,16 +1,14 @@
-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.synthesizeNumbaFlow import makeNumbaFlow
+from mapFolding.someAssemblyRequired import importLogicalPath2Callable, RecipeSynthesizeFlow
+from mapFolding.theSSOT import ComputationState, The, getPackageDispatcher
 from pathlib import Path, PurePosixPath
-from typing import Any, ContextManager
+from types import ModuleType
+from typing import Any
+import importlib
 import importlib.util
+import numpy
 import pytest
 import random
 import shutil
@@ -18,8 +16,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 +99,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 +129,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 +173,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,46 +201,47 @@ 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(
-        pathPackage=PurePosixPath(pathTmpTesting.absolute()),
-        Z0Z_flowLogicalPathRoot=None,
-        moduleDispatcher="test_dispatcher",
+	"""Generate synthetic Numba-optimized dispatcher module and patch the dispatcher"""
+	from mapFolding.someAssemblyRequired.toolboxNumba import makeNumbaFlow
+
+	TESTINGrecipeFlow = RecipeSynthesizeFlow(
+		pathPackage=PurePosixPath(pathTmpTesting.absolute()),
+		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)
-
-    # Import synthesized dispatcher
-    importlibSpecificationDispatcher = importlib.util.spec_from_file_location(
-        recipeFlow.moduleDispatcher,
-        Path(recipeFlow.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)
-
-    # Patch dispatcher and return callable
-    useThisDispatcher(callableDispatcherSynthetic)
-    return callableDispatcherSynthetic
+		# dispatcherCallable="dispatcherSynthetic",
+	)
+
+	# Generate optimized module in test directory
+	makeNumbaFlow(TESTINGrecipeFlow)
+
+	# Import synthesized dispatcher
+	importlibSpecificationDispatcher = importlib.util.spec_from_file_location(
+		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, TESTINGrecipeFlow.callableDispatcher)
+
+	# Patch dispatcher and return callable
+	useThisDispatcher(callableDispatcherSynthetic)
+	return callableDispatcherSynthetic
 
 def uniformTestMessage(expected: Any, actual: Any, functionName: str, *arguments: Any) -> str:
 	"""Format assertion message for any test comparison."""

tests/test_computations.py

@@ -1,53 +1,63 @@
 from mapFolding.basecamp import countFolds
-from mapFolding.filesystem import getPathFilenameFoldsTotal
+from mapFolding.toolboxFilesystem 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.transformationTools 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:
+	from mapFolding.someAssemblyRequired.toolboxNumba import RecipeJob, SpicesJobNumba
+	from mapFolding.someAssemblyRequired.synthesizeNumbaJob import makeJobNumba
+	mapShape = validateListDimensions(oneTestCuzTestsOverwritingTests)
+	state = makeInitializedComputationState(mapShape)
+
+	pathFilenameModule = pathFilenameTmpTesting.absolute()
+	pathFilenameFoldsTotal = pathFilenameModule.with_suffix('.foldsTotalTesting')
+	registrarRecordsTmpObject(pathFilenameFoldsTotal)
+
+	jobTest = RecipeJob(state
+						, pathModule=PurePosixPath(pathFilenameModule.parent)
+						, moduleIdentifier=pathFilenameModule.stem
+						, pathFilenameFoldsTotal=PurePosixPath(pathFilenameFoldsTotal))
+	spices = SpicesJobNumba()
+	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:
+		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.toolboxFilesystem import getFilenameFoldsTotal, getPathFilenameFoldsTotal, saveFoldsTotal
 from mapFolding.beDRY import validateListDimensions
-from mapFolding.theSSOT import getPathJobRootDEFAULT
+from mapFolding.toolboxFilesystem 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

@@ -1,5 +1,5 @@
 from collections.abc import Callable
-from mapFolding.beDRY import getLeavesTotal, setCPUlimit, validateListDimensions
+from mapFolding.beDRY import getLeavesTotal, setProcessorLimit, validateListDimensions
 from mapFolding.theSSOT import The
 from tests.conftest import standardizedEqualToCallableReturn
 from typing import Any, Literal
@@ -81,4 +81,4 @@ def testOopsieKwargsie(nameOfTest: str, callablePytest: Callable[[], None]) -> N
 ])
 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')
+	standardizedEqualToCallableReturn(expectedLimit, setProcessorLimit, CPUlimit, 'numba')

tests/test_tasks.py

@@ -1,6 +1,6 @@
 from collections.abc import Callable
 from mapFolding.basecamp import countFolds
-from mapFolding.beDRY import getTaskDivisions, setCPUlimit, validateListDimensions, getLeavesTotal
+from mapFolding.beDRY import getTaskDivisions, setProcessorLimit, validateListDimensions, getLeavesTotal
 from mapFolding.noHomeYet import getFoldsTotalKnown
 from tests.conftest import standardizedEqualToCallableReturn
 from typing import Literal
@@ -49,4 +49,4 @@ def test_getTaskDivisions(computationDivisions: None | list[str] | Literal['maxi
 ])
 def test_setCPUlimitMalformedParameter(expected: type[ValueError] | Literal[2], parameter: list[int] | tuple[int] | set[int] | dict[str, int] | Literal['2']) -> None:
 	"""Test that invalid CPUlimit types are properly handled."""
-	standardizedEqualToCallableReturn(expected, setCPUlimit, parameter)
+	standardizedEqualToCallableReturn(expected, setProcessorLimit, parameter)

mapFolding/filesystem.py

@@ -1,129 +0,0 @@
-"""
-Filesystem utilities for managing map folding computation results.
-
-This module provides functions for standardized handling of files related to the mapFolding
-package, with a focus on saving, retrieving, and naming computation results. It implements
-consistent naming conventions and path resolution strategies to ensure that:
-
-1. Computation results are stored in a predictable location
-2. Filenames follow a consistent pattern based on map dimensions
-3. Results can be reliably retrieved for future reference
-4. The system handles file operations safely with appropriate error handling
-
-The module serves as the interface between the computational components of the package
-and the filesystem, abstracting away the details of file operations and path management.
-"""
-from pathlib import Path, PurePath
-from typing import Any
-from os import PathLike
-import os
-
-def getFilenameFoldsTotal(mapShape: tuple[int, ...]) -> str:
-    """
-    Create a standardized filename for a computed `foldsTotal` value.
-
-    This function generates a consistent, filesystem-safe filename based on map dimensions.
-    Standardizing filenames ensures that results can be reliably stored and retrieved,
-    avoiding potential filesystem incompatibilities or Python naming restrictions.
-
-    Parameters:
-        mapShape: A sequence of integers representing the dimensions of the map.
-
-    Returns:
-        filenameFoldsTotal: A filename string in format 'pMxN.foldsTotal' where M,N are sorted dimensions.
-
-    Notes:
-        The filename format ensures:
-        - No spaces in the filename
-        - Safe filesystem characters
-        - Unique extension (.foldsTotal)
-        - Python-safe strings (no starting with numbers, no reserved words)
-        - The 'p' prefix preserves compatibility with Lunnan's original code.
-    """
-    return 'p' + 'x'.join(str(dimension) for dimension in sorted(mapShape)) + '.foldsTotal'
-
-def getPathFilenameFoldsTotal(mapShape: tuple[int, ...], pathLikeWriteFoldsTotal: str | PathLike[str] | None = None) -> Path:
-    """
-    Get a standardized path and filename for the computed foldsTotal value.
-
-    This function resolves paths for storing computation results, handling different
-    input types including directories, absolute paths, or relative paths. It ensures
-    that all parent directories exist in the resulting path.
-
-    Parameters:
-        mapShape: List of dimensions for the map folding problem.
-        pathLikeWriteFoldsTotal (getPathJobRootDEFAULT): Path, filename, or relative path and filename.
-            If None, uses default path. If a directory, appends standardized filename.
-
-    Returns:
-        pathFilenameFoldsTotal: Absolute path and filename for storing the foldsTotal value.
-
-    Notes:
-        The function creates any necessary directories in the path if they don't exist.
-    """
-    from mapFolding.theSSOT import getPathJobRootDEFAULT
-
-    if pathLikeWriteFoldsTotal is None:
-        pathFilenameFoldsTotal = getPathJobRootDEFAULT() / getFilenameFoldsTotal(mapShape)
-    else:
-        pathLikeSherpa = Path(pathLikeWriteFoldsTotal)
-        if pathLikeSherpa.is_dir():
-            pathFilenameFoldsTotal = pathLikeSherpa / getFilenameFoldsTotal(mapShape)
-        elif pathLikeSherpa.is_file() and pathLikeSherpa.is_absolute():
-            pathFilenameFoldsTotal = pathLikeSherpa
-        else:
-            pathFilenameFoldsTotal = getPathJobRootDEFAULT() / pathLikeSherpa
-
-    pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
-    return pathFilenameFoldsTotal
-
-def saveFoldsTotal(pathFilename: str | PathLike[str], foldsTotal: int) -> None:
-    """
-    Save `foldsTotal` value to disk with multiple fallback mechanisms.
-
-    This function attempts to save the computed `foldsTotal` value to the specified
-    location, with backup strategies in case the primary save attempt fails.
-    The robustness is critical since these computations may take days to complete.
-
-    Parameters:
-        pathFilename: Target save location for the `foldsTotal` value
-        foldsTotal: The computed value to save
-
-    Notes:
-        If the primary save fails, the function will attempt alternative save methods:
-        1. Print the value prominently to stdout
-        2. Create a fallback file in the current working directory
-        3. As a last resort, simply print the value
-    """
-    try:
-        pathFilenameFoldsTotal = Path(pathFilename)
-        pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
-        pathFilenameFoldsTotal.write_text(str(foldsTotal))
-    except Exception as ERRORmessage:
-        try:
-            print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
-            print(ERRORmessage)
-            print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
-            randomnessPlanB = (int(str(foldsTotal).strip()[-1]) + 1) * ['YO_']
-            filenameInfixUnique = ''.join(randomnessPlanB)
-            pathFilenamePlanB = os.path.join(os.getcwd(), 'foldsTotal' + filenameInfixUnique + '.txt')
-            writeStreamFallback = open(pathFilenamePlanB, 'w')
-            writeStreamFallback.write(str(foldsTotal))
-            writeStreamFallback.close()
-            print(str(pathFilenamePlanB))
-        except Exception:
-            print(foldsTotal)
-    return None
-
-def writeStringToHere(this: str, pathFilename: str | PathLike[Any] | PurePath) -> None:
-    """
-    Write a string to a file, creating parent directories if needed.
-
-    Parameters:
-        this: The string content to write to the file
-        pathFilename: The target file path where the string should be written
-    """
-    pathFilename = Path(pathFilename)
-    pathFilename.parent.mkdir(parents=True, exist_ok=True)
-    pathFilename.write_text(str(this))
-    return None