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

tests/conftest.py

@@ -1,8 +1,14 @@
+from importlib import import_module as importlib_import_module
 from collections.abc import Callable, Generator, Sequence
-from mapFolding.theSSOT import getAlgorithmDispatcher, getSourceAlgorithm, getPackageDispatcher, theModuleOfSyntheticModules, raiseIfNoneGitHubIssueNumber3
+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 pathlib import Path
+from mapFolding.someAssemblyRequired import RecipeSynthesizeFlow
+from mapFolding.someAssemblyRequired.synthesizeNumbaFlow import makeNumbaFlow
+from pathlib import Path, PurePosixPath
 from typing import Any, ContextManager
 import importlib.util
 import pytest
@@ -13,7 +19,6 @@ import uuid
 
 # SSOT for test data paths and filenames
 pathDataSamples = Path("tests/dataSamples")
-# NOTE `tmp` is not a diminutive form of temporary: it signals a technical term. And "temp" is strongly disfavored.
 pathTmpRoot: Path = pathDataSamples / "tmp"
 
 # The registrar maintains the register of temp files
@@ -142,7 +147,7 @@ def mockBenchmarkTimer() -> Generator[unittest.mock.MagicMock | unittest.mock.As
 def mockFoldingFunction() -> Callable[..., Callable[..., None]]:
 	"""Creates a mock function that simulates _countFolds behavior."""
 	def make_mock(foldsValue: int, listDimensions: list[int]) -> Callable[..., None]:
-		mock_array = makeDataContainer(2)
+		mock_array = makeDataContainer(2, numpy.int32)
 		mock_array[0] = foldsValue
 		mapShape = validateListDimensions(listDimensions)
 		mock_array[-1] = getLeavesTotal(mapShape)
@@ -192,6 +197,11 @@ def useThisDispatcher() -> Generator[Callable[..., None], Any, None]:
 	yield patchDispatcher
 	basecamp.getPackageDispatcher = dispatcherOriginal
 
+def getAlgorithmDispatcher() -> Callable[[ComputationState], ComputationState]:
+	moduleImported: ModuleType = importlib_import_module(The.logicalPathModuleSourceAlgorithm)
+	dispatcherCallable = getattr(moduleImported, The.dispatcherCallable)
+	return dispatcherCallable
+
 @pytest.fixture
 def useAlgorithmSourceDispatcher(useThisDispatcher: Callable[..., Any]) -> Generator[None, None, None]:
 	"""Temporarily patches getDispatcherCallable to return the algorithm dispatcher."""
@@ -199,35 +209,35 @@ def useAlgorithmSourceDispatcher(useThisDispatcher: Callable[..., Any]) -> Gener
 	yield
 
 @pytest.fixture
-def syntheticDispatcherFixture(useThisDispatcher: Callable[..., Any]) -> Callable[..., Any]:
-	listCallablesInline = listNumbaCallableDispatchees
-	callableDispatcher = True
-	algorithmSource = getSourceAlgorithm()
-	relativePathWrite = theModuleOfSyntheticModules
-	filenameModuleWrite = 'pytestCount.py'
-	formatFilenameWrite = "pytest_{callableTarget}.py"
-	listSynthesizedModules: list[YouOughtaKnow] = makeFlowNumbaOptimized(listCallablesInline, callableDispatcher, algorithmSource, relativePathWrite, filenameModuleWrite, formatFilenameWrite)
-	dispatcherSynthetic: YouOughtaKnow | None = None
-	for stuff in listSynthesizedModules:
-		registrarRecordsTmpObject(stuff.pathFilenameForMe)
-		if stuff.callableSynthesized not in listCallablesInline:
-			dispatcherSynthetic = stuff
-
-	if dispatcherSynthetic is None:
-		raise raiseIfNoneGitHubIssueNumber3
-
-	dispatcherSpec = importlib.util.spec_from_file_location(dispatcherSynthetic.callableSynthesized, dispatcherSynthetic.pathFilenameForMe)
-	if dispatcherSpec is None:
-		raise ImportError(f"{dispatcherSynthetic.pathFilenameForMe=}")
-	if dispatcherSpec.loader is None:
-		raise ImportError(f"Failed to get loader for module {dispatcherSynthetic.pathFilenameForMe}")
-
-	dispatcherModule = importlib.util.module_from_spec(dispatcherSpec)
-	dispatcherSpec.loader.exec_module(dispatcherModule)
-	callableDispatcherSynthetic = getattr(dispatcherModule, dispatcherSynthetic.callableSynthesized)
-
-	useThisDispatcher(callableDispatcherSynthetic)
-	return callableDispatcherSynthetic
+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",
+# 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
 
 def uniformTestMessage(expected: Any, actual: Any, functionName: str, *arguments: Any) -> str:
 	"""Format assertion message for any test comparison."""

tests/test_computations.py

@@ -23,6 +23,12 @@ def test_aOFn_calculate_value(oeisID: str) -> None:
     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')
+
+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
@@ -44,10 +50,4 @@ def test_aOFn_calculate_value(oeisID: str) -> None:
 
 #     pathFilenameFoldsTotal = getPathFilenameFoldsTotal(listDimensionsTestCountFolds)
 #     registrarRecordsTmpObject(pathFilenameFoldsTotal)
-#     standardizedEqualTo(str(foldsTotalKnown[tuple(listDimensionsTestCountFolds)]), pathFilenameFoldsTotal.read_text().strip)
-
-# def test_syntheticParallel(syntheticDispatcherFixture: None, listDimensionsTestParallelization: list[int], foldsTotalKnown: dict[tuple[int, ...], int]):
-#     standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
-
-# def test_syntheticSequential(syntheticDispatcherFixture: None, listDimensionsTestCountFolds: list[int], foldsTotalKnown: dict[tuple[int, ...], int]):
-#     standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestCountFolds)], countFolds, listDimensionsTestCountFolds)
+#     standardizedEqualToCallableReturn(str(getFoldsTotalKnown(tuple(listDimensionsTestCountFolds))), pathFilenameFoldsTotal.read_text().strip)

tests/test_other.py

@@ -1,5 +1,6 @@
 from collections.abc import Callable
 from mapFolding.beDRY import getLeavesTotal, setCPUlimit, validateListDimensions
+from mapFolding.theSSOT import The
 from tests.conftest import standardizedEqualToCallableReturn
 from typing import Any, Literal
 from Z0Z_tools import intInnit
@@ -78,6 +79,5 @@ def testOopsieKwargsie(nameOfTest: str, callablePytest: Callable[[], None]) -> N
 	(1, 1),
 ])
 def test_setCPUlimit(CPUlimit: None | float | bool | Literal[4] | Literal[-2] | Literal[0] | Literal[1], expectedLimit: Any | int) -> None:
-	from mapFolding.theSSOT import concurrencyPackage
-	if concurrencyPackage == 'numba':
+	if The.concurrencyPackage == 'numba':
 		standardizedEqualToCallableReturn(expectedLimit, setCPUlimit, CPUlimit)

mapFolding/reference/lunnan.py

@@ -1,153 +0,0 @@
-"""
-An unnecessarily literal translation of the original Atlas Autocode code by W. F. Lunnon to Python.
-W. F. Lunnon, Multi-dimensional map-folding, The Computer Journal, Volume 14, Issue 1, 1971, Pages 75-80, https://doi.org/10.1093/comjnl/14.1.75
-"""# NOTE not functional yet
-def foldings(p, job=None):
-	"""An unnecessarily literal translation of the original Atlas Autocode code."""
-	p = list(p)
-	p.append(None)  # NOTE mimics Atlas `array` type
-	p.insert(0, None)  # NOTE mimics Atlas `array` type
-
-	if job is None:
-		global G
-		G = 0
-		def job(A, B):
-			global G
-			G = G + 1
-		return foldings(p, job)
-	# perform job (A, B) on each folding of a p[1] x ... x p[d] map,
-	# where A and B are the above and below vectors. p[d + 1] < 0 terminates p;
-
-	d: int
-	n: int
-	j: int
-	i: int
-	m: int
-	l: int
-	g: int
-	gg: int
-	dd: int
-
-	n = 1
-	i, d = 0, 0
-
-	while (i := i + 1) and p[i] is not None:
-		d = i
-		n = n * p[i]
-
-	# d dimensions and n leaves;
-
-	# A: list[int] = [None] * (n + 1) # type: ignore
-	# B: list[int] = [None] * (n + 1) # type: ignore
-	# count: list[int] = [None] * (n + 1) # type: ignore
-	# gapter: list[int] = [None] * (n + 1) # type: ignore
-	# gap: list[int] = [None] * (n * n + 1) # type: ignore
-	A: list[int] = [0] * (n + 1) # type: ignore
-	B: list[int] = [0] * (n + 1) # type: ignore
-	count: list[int] = [0] * (n + 1) # type: ignore
-	gapter: list[int] = [0] * (n + 1) # type: ignore
-	gap: list[int] = [0] * (n * n + 1) # type: ignore
-
-	# B[m] is the leaf below leaf m in the current folding,
-	# A[m] the leaf above. count[m] is the no. of sections in which
-	# there is a gap for the new leaf l below leaf m,
-	# gap[gapter[l - 1] + j] is the j-th (possible or actual) gap for leaf l,
-	# and later gap[gapter[l]] is the gap where leaf l is currently inserted;
-
-	P: list[int] = [0] * (d + 1) # type: ignore
-	C: list[list[int]] = [[0] * (n + 1) for dimension1 in range(d + 1)] # type: ignore
-	# D: list[list[list[int]]] = [[[None] * (n + 1) for dimension2 in range(n + 1)] for dimension1 in range(d + 1)] # type: ignore
-	D: list[list[list[int]]] = [[[0] * (n + 1) for dimension2 in range(n + 1)] for dimension1 in range(d + 1)]
-
-	P[0] = 1
-	for i in range(1, d + 1):
-		P[i] = P[i - 1] * p[i]
-
-	for i in range(1, d + 1):
-		for m in range(1, n + 1):
-			C[i][m] = ((m - 1) // P[i - 1]) - ((m - 1) // P[i]) * p[i] + 1
-
-	for i in range(1, d + 1):
-		for l in range(1, n + 1):
-			for m in range(1, l + 1):
-				D[i][l][m] = (0 if m == 0
-								else
-										((m if C[i][m] == 1
-											else m - P[i - 1])
-									if C[i][l] - C[i][m] == (C[i][l] - C[i][m]) // 2 * 2
-									else
-										(m if C[i][m] == p[i] or m + P[i - 1] > l
-											else m + P[i - 1])))
-	# P[i] = p[1] x ... x p[i], C[i][m] = i-th co-ordinate of leaf m,
-	# D[i][l][m] = leaf connected to m in section i when inserting l;
-
-	for m in range(n + 1):
-		count[m] = 0
-
-	A[0], B[0], g, l = 0, 0, 0, 0
-
-	state = 'entry'
-	while True:
-		if state == 'entry':
-			gapter[l] = g
-			l = l + 1
-			if l <= n:
-				state = 'down'
-				continue
-			else:
-				job(A, B)
-				state = 'up'
-				continue
-
-		elif state == 'down':
-			dd = 0
-			gg = gapter[l - 1]
-			g = gg
-			for i in range(1, d + 1):
-				if D[i][l][l] == l:
-					dd = dd + 1
-				else:
-					m = D[i][l][l]
-					while m != l:
-						gap[gg] = m
-						if count[m] == 0:
-							gg = gg + 1
-						count[m] = count[m] + 1
-						m = D[i][l][B[m]]
-
-			if dd == d:
-				for m in range(l):
-					gap[gg] = m
-					gg = gg + 1
-
-			for j in range(g, gg):
-				gap[g] = gap[j]
-				if count[gap[j]] == d - dd:
-					g = g + 1
-				count[gap[j]] = 0
-			state = 'along'
-			continue
-
-		elif state == 'along':
-			if g == gapter[l - 1]:
-				state = 'up'
-				continue
-			g = g - 1
-			A[l] = gap[g]
-			B[l] = B[A[l]]
-			B[A[l]] = l
-			A[B[l]] = l
-			state = 'entry'
-			continue
-
-		elif state == 'up':
-			l = l - 1
-			B[A[l]] = B[l]
-			A[B[l]] = A[l]
-			if l > 0:
-				state = 'along'
-				continue
-			else:
-				break
-
-	return G #if job.__closure__ else None

mapFolding/someAssemblyRequired/Z0Z_workbench.py

@@ -1,350 +0,0 @@
-from autoflake import fix_code as autoflake_fix_code
-from mapFolding.filesystem import writeStringToHere
-from mapFolding.someAssemblyRequired import (
-	ast_Identifier,
-	extractFunctionDef,
-	ifThis,
-	IngredientsFunction,
-	IngredientsModule,
-	LedgerOfImports,
-	Make,
-	makeDictionaryReplacementStatements,
-	NodeCollector,
-	NodeReplacer,
-	RecipeSynthesizeFlow,
-	strDotStrCuzPyStoopid,
-	Then,
-)
-from mapFolding.someAssemblyRequired.ingredientsNumba import decorateCallableWithNumba
-from mapFolding.someAssemblyRequired.synthesizeDataConverters import shatter_dataclassesDOTdataclass
-from mapFolding.theSSOT import raiseIfNoneGitHubIssueNumber3
-from pathlib import Path
-import ast
-
-# Would `LibCST` be better than `ast` in some cases? https://github.com/hunterhogan/mapFolding/issues/7
-
-def Z0Z_alphaTest_putModuleOnDisk(ingredients: IngredientsModule, recipeFlow: RecipeSynthesizeFlow):
-	# Physical namespace
-	filenameStem: str = recipeFlow.moduleDispatcher
-	fileExtension: str = recipeFlow.fileExtension
-	pathPackage: Path = Path(recipeFlow.pathPackage)
-
-	# Physical and logical namespace
-	packageName: ast_Identifier | None = recipeFlow.packageName # module name of the package, if any
-	logicalPathINFIX: ast_Identifier | strDotStrCuzPyStoopid | None = recipeFlow.Z0Z_flowLogicalPathRoot
-
-	def _getLogicalPathParent() -> str | None:
-		listModules: list[ast_Identifier] = []
-		if packageName:
-			listModules.append(packageName)
-		if logicalPathINFIX:
-			listModules.append(logicalPathINFIX)
-		if listModules:
-			return '.'.join(listModules)
-		return None
-
-	def _getLogicalPathAbsolute() -> str:
-		listModules: list[ast_Identifier] = []
-		logicalPathParent: str | None = _getLogicalPathParent()
-		if logicalPathParent:
-			listModules.append(logicalPathParent)
-		listModules.append(filenameStem)
-		return '.'.join(listModules)
-
-	def getPathFilename():
-		pathRoot: Path = pathPackage
-		filename: str = filenameStem + fileExtension
-		if logicalPathINFIX:
-			whyIsThisStillAThing: list[str] = logicalPathINFIX.split('.')
-			pathRoot = pathRoot.joinpath(*whyIsThisStillAThing)
-		return pathRoot.joinpath(filename)
-
-	def absoluteImport() -> ast.Import:
-		return Make.astImport(_getLogicalPathAbsolute())
-
-	def absoluteImportFrom() -> ast.ImportFrom:
-		""" `from . import theModule` """
-		logicalPathParent: str = _getLogicalPathParent() or '.'
-		return Make.astImportFrom(logicalPathParent, [Make.astAlias(filenameStem)])
-
-	def writeModule() -> None:
-		astModule = ingredients.export()
-		ast.fix_missing_locations(astModule)
-		pythonSource: str = ast.unparse(astModule)
-		if not pythonSource: raise raiseIfNoneGitHubIssueNumber3
-		autoflake_additional_imports: list[str] = ingredients.imports.exportListModuleNames()
-		if packageName:
-			autoflake_additional_imports.append(packageName)
-		pythonSource = autoflake_fix_code(pythonSource, autoflake_additional_imports, expand_star_imports=False, remove_all_unused_imports=False, remove_duplicate_keys = False, remove_unused_variables = False,)
-		pathFilename = getPathFilename()
-		writeStringToHere(pythonSource, pathFilename)
-
-	writeModule()
-
-def inlineThisFunctionWithTheseValues(astFunctionDef: ast.FunctionDef, dictionaryReplacementStatements: dict[str, ast.stmt | list[ast.stmt]]) -> ast.FunctionDef:
-	class FunctionInliner(ast.NodeTransformer):
-		def __init__(self, dictionaryReplacementStatements: dict[str, ast.stmt | list[ast.stmt]]) -> None:
-			self.dictionaryReplacementStatements = dictionaryReplacementStatements
-
-		def generic_visit(self, node: ast.AST) -> ast.AST:
-			"""Visit all nodes and replace them if necessary."""
-			return super().generic_visit(node)
-
-		def visit_Expr(self, node: ast.Expr) -> ast.AST | list[ast.stmt]:
-			"""Visit Expr nodes and replace value if it's a function call in our dictionary."""
-			if ifThis.CallDoesNotCallItselfAndNameDOTidIsIn(self.dictionaryReplacementStatements)(node.value):
-				return self.dictionaryReplacementStatements[node.value.func.id] # type: ignore[attr-defined]
-			return node
-
-		def visit_Assign(self, node: ast.Assign) -> ast.AST | list[ast.stmt]:
-			"""Visit Assign nodes and replace value if it's a function call in our dictionary."""
-			if ifThis.CallDoesNotCallItselfAndNameDOTidIsIn(self.dictionaryReplacementStatements)(node.value):
-				return self.dictionaryReplacementStatements[node.value.func.id] # type: ignore[attr-defined]
-			return node
-
-		def visit_Call(self, node: ast.Call) -> ast.AST | list[ast.stmt]:
-			"""Replace call nodes with their replacement statements if they're in the dictionary."""
-			if ifThis.CallDoesNotCallItselfAndNameDOTidIsIn(self.dictionaryReplacementStatements)(node):
-				replacement = self.dictionaryReplacementStatements[node.func.id] # type: ignore[attr-defined]
-				if not isinstance(replacement, list):
-					return replacement
-			return node
-
-	import copy
-	keepGoing = True
-	ImaInlineFunction = copy.deepcopy(astFunctionDef)
-	while keepGoing:
-		ImaInlineFunction = copy.deepcopy(astFunctionDef)
-		FunctionInliner(copy.deepcopy(dictionaryReplacementStatements)).visit(ImaInlineFunction)
-		if ast.unparse(ImaInlineFunction) == ast.unparse(astFunctionDef):
-			keepGoing = False
-		else:
-			astFunctionDef = copy.deepcopy(ImaInlineFunction)
-	return ImaInlineFunction
-
-def replaceMatchingASTnodes(astTree: ast.AST, replacementMap: list[tuple[ast.AST, ast.AST]]) -> ast.AST:
-	"""Replace matching AST nodes using type-specific visitors.
-
-	Parameters:
-		astTree: The AST to transform
-		replacementMap: List of (find, replace) node pairs
-
-	Returns:
-		The transformed AST
-	"""
-	class TargetedNodeReplacer(ast.NodeTransformer):
-		def __init__(self, replacementMap: list[tuple[ast.AST, ast.AST]]) -> None:
-			# Group replacements by node type for more efficient lookups
-			self.replacementByType: dict[type[ast.AST], list[tuple[ast.AST, ast.AST]]] = {}
-			for findNode, replaceNode in replacementMap:
-				nodeType = type(findNode)
-				if nodeType not in self.replacementByType:
-					self.replacementByType[nodeType] = []
-				self.replacementByType[nodeType].append((findNode, replaceNode))
-
-		def visit(self, node: ast.AST) -> ast.AST:
-			"""Check if this node should be replaced before continuing traversal."""
-			nodeType = type(node)
-			if nodeType in self.replacementByType:
-				for findNode, replaceNode in self.replacementByType[nodeType]:
-					if self.nodesMatchStructurally(node, findNode):
-						return replaceNode
-			return super().visit(node)
-
-		def nodesMatchStructurally(self, node1: ast.AST | list, node2: ast.AST | list) -> bool:
-			"""Compare two AST nodes structurally, ignoring position information."""
-			# Different types can't be equal
-			if type(node1) != type(node2):
-				return False
-
-			if isinstance(node1, ast.AST):
-				# Compare fields that matter for structural equality
-				fields = [f for f in node1._fields
-							if f not in ('lineno', 'col_offset', 'end_lineno', 'end_col_offset', 'ctx')]
-
-				for field in fields:
-					smurf1 = getattr(node1, field, None)
-					smurf2 = getattr(node2, field, None)
-
-					if isinstance(smurf1, (ast.AST, list)) and isinstance(smurf2, (ast.AST, list)):
-						if not self.nodesMatchStructurally(smurf1, smurf2):
-							return False
-					elif smurf1 != smurf2:
-						return False
-				return True
-
-			elif isinstance(node1, list) and isinstance(node2, list):
-				if len(node1) != len(node2):
-					return False
-				return all(self.nodesMatchStructurally(x, y) for x, y in zip(node1, node2))
-
-			else:
-				# Direct comparison for non-AST objects (strings, numbers, etc.)
-				return node1 == node2
-
-	import copy
-	keepGoing = True
-	astResult = copy.deepcopy(astTree)
-
-	while keepGoing:
-		astBeforeChange = copy.deepcopy(astResult)
-		TargetedNodeReplacer(copy.deepcopy(replacementMap)).visit(astResult)
-
-		# Check if we've reached a fixed point (no more changes)
-		if ast.unparse(astResult) == ast.unparse(astBeforeChange):
-			keepGoing = False
-
-	return astResult
-
-def Z0Z_main() -> None:
-	numbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()
-	dictionaryReplacementStatements = makeDictionaryReplacementStatements(numbaFlow.source_astModule)
-	# TODO remove hardcoding
-	theCountingIdentifierHARDCODED = 'groupsOfFolds'
-	theCountingIdentifier = theCountingIdentifierHARDCODED
-
-	# TODO remember that `sequentialCallable` and `sourceSequentialCallable` are two different values.
-	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-
-	# ===========================================================
-	sourcePython = numbaFlow.sourceDispatcherCallable
-	astFunctionDef = extractFunctionDef(sourcePython, numbaFlow.source_astModule)
-	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
-	ingredientsDispatcher = IngredientsFunction(astFunctionDef, LedgerOfImports(numbaFlow.source_astModule))
-
-	# sourceParallelCallable
-	(astName_dataclassesDOTdataclass, ledgerDataclassANDFragments, listAnnAssign4DataclassUnpack,
-		astTuple4AssignTargetsToFragments, listNameDataclassFragments4Parameters, list_ast_argAnnotated4ArgumentsSpecification,
-		astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns, astAssignDataclassRepack, list_keyword4DataclassInitialization) = shatter_dataclassesDOTdataclass(
-			numbaFlow.logicalPathModuleDataclass, numbaFlow.sourceDataclassIdentifier, numbaFlow.sourceDataclassInstanceTaskDistribution)
-	ingredientsDispatcher.imports.update(ledgerDataclassANDFragments)
-
-	# TODO remove hardcoding
-	namespaceHARDCODED = 'concurrencyManager'
-	identifierHARDCODED = 'submit'
-	namespace = namespaceHARDCODED
-	identifier = identifierHARDCODED
-	NodeReplacer(
-		findThis = ifThis.isAssignAndValueIsCallNamespace_Identifier(namespace, identifier)
-		, doThat = Then.insertThisAbove(listAnnAssign4DataclassUnpack)
-			).visit(ingredientsDispatcher.astFunctionDef)
-	NodeReplacer(
-		findThis = ifThis.isCallNamespace_Identifier(namespace, identifier)
-		, doThat = Then.replaceWith(Make.astCall(Make.astAttribute(Make.astName(namespace), identifier)
-									, listArguments=[Make.astName(numbaFlow.parallelCallable)] + listNameDataclassFragments4Parameters))
-			).visit(ingredientsDispatcher.astFunctionDef)
-
-	CapturedAssign: list[ast.AST] = []
-	CapturedCall: list[ast.Call] = []
-	findThis = ifThis.isCall
-	doThat = [Then.appendTo(CapturedCall)]
-	capture = NodeCollector(findThis, doThat)
-
-	NodeCollector(
-		findThis = ifThis.isAssignAndTargets0Is(ifThis.isSubscript_Identifier(numbaFlow.sourceDataclassInstance))
-		, doThat = [Then.appendTo(CapturedAssign)
-					, lambda node: capture.visit(node)]
-			).visit(ingredientsDispatcher.astFunctionDef)
-
-	newAssign = CapturedAssign[0]
-	NodeReplacer(
-		findThis = lambda node: ifThis.isSubscript(node) and ifThis.isAttribute(node.value) and ifThis.isCall(node.value.value)
-		, doThat = Then.replaceWith(CapturedCall[0])
-			).visit(newAssign)
-
-	NodeReplacer(
-		findThis = ifThis.isAssignAndTargets0Is(ifThis.isSubscript_Identifier(numbaFlow.sourceDataclassInstance))
-		, doThat = Then.replaceWith(newAssign)
-			).visit(ingredientsDispatcher.astFunctionDef)
-
-	# sourceSequentialCallable
-	(astName_dataclassesDOTdataclass, ledgerDataclassANDFragments, listAnnAssign4DataclassUnpack,
-		astTuple4AssignTargetsToFragments, listNameDataclassFragments4Parameters, list_ast_argAnnotated4ArgumentsSpecification,
-		astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns, astAssignDataclassRepack, list_keyword4DataclassInitialization) = shatter_dataclassesDOTdataclass(
-			numbaFlow.logicalPathModuleDataclass, numbaFlow.sourceDataclassIdentifier, numbaFlow.sourceDataclassInstance)
-	ingredientsDispatcher.imports.update(ledgerDataclassANDFragments)
-
-	NodeReplacer(
-		findThis = ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.sourceSequentialCallable)
-		, doThat = Then.insertThisAbove(listAnnAssign4DataclassUnpack)
-			).visit(ingredientsDispatcher.astFunctionDef)
-	NodeReplacer(
-		findThis = ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.sourceSequentialCallable)
-		# findThis = ifThis.isReturn
-		, doThat = Then.insertThisBelow([astAssignDataclassRepack])
-			).visit(ingredientsDispatcher.astFunctionDef)
-	# TODO reconsider: This calls a function, but I don't inspect the function for its parameters or return.
-	NodeReplacer(
-		findThis = ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.sourceSequentialCallable)
-		, doThat = Then.replaceWith(Make.astAssign(listTargets=[astTuple4AssignTargetsToFragments], value=Make.astCall(Make.astName(numbaFlow.sequentialCallable), listNameDataclassFragments4Parameters)))
-			).visit(ingredientsDispatcher.astFunctionDef)
-
-	# ===========================================================
-	sourcePython = numbaFlow.sourceInitializeCallable
-	astFunctionDef = extractFunctionDef(sourcePython, numbaFlow.source_astModule)
-	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
-	astFunctionDef = inlineThisFunctionWithTheseValues(astFunctionDef, dictionaryReplacementStatements)
-	ingredientsInitialize = IngredientsFunction(astFunctionDef, LedgerOfImports(numbaFlow.source_astModule))
-
-	# ===========================================================
-	sourcePython = numbaFlow.sourceParallelCallable
-	astFunctionDef = extractFunctionDef(sourcePython, numbaFlow.source_astModule)
-	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
-	astFunctionDef = inlineThisFunctionWithTheseValues(astFunctionDef, dictionaryReplacementStatements)
-	ingredientsParallel = IngredientsFunction(astFunctionDef, LedgerOfImports(numbaFlow.source_astModule))
-	ingredientsParallel.astFunctionDef.name = numbaFlow.parallelCallable
-	ingredientsParallel.astFunctionDef.args = Make.astArgumentsSpecification(args=list_ast_argAnnotated4ArgumentsSpecification)
-	NodeReplacer(
-		findThis = ifThis.isReturn
-		, doThat = Then.replaceWith(Make.astReturn(astTuple4AssignTargetsToFragments))
-			).visit(ingredientsParallel.astFunctionDef)
-	NodeReplacer(
-		findThis = ifThis.isReturn
-		# , doThat = Then.replaceWith(Make.astReturn(astTuple4AssignTargetsToFragments))
-		, doThat = Then.replaceWith(Make.astReturn(Make.astName(theCountingIdentifier)))
-			).visit(ingredientsParallel.astFunctionDef)
-	theCountingIdentifierAnnotation = next(
-		ast_arg.annotation for ast_arg in list_ast_argAnnotated4ArgumentsSpecification if ast_arg.arg == theCountingIdentifier)
-	ingredientsParallel.astFunctionDef.returns = theCountingIdentifierAnnotation
-	# ingredientsParallel.astFunctionDef.returns = astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns
-	replacementMap = [(statement.value, statement.target) for statement in listAnnAssign4DataclassUnpack]
-	ingredientsParallel.astFunctionDef = replaceMatchingASTnodes(
-		ingredientsParallel.astFunctionDef, replacementMap) # type: ignore
-	# TODO a tool to automatically remove unused variables from the ArgumentsSpecification (return, and returns) _might_ be nice.
-	# But, I would need to update the calling function, too.
-	ingredientsParallel = decorateCallableWithNumba(ingredientsParallel) # parametersNumbaParallelDEFAULT
-
-	# ===========================================================
-	sourcePython = numbaFlow.sourceSequentialCallable
-	astFunctionDef = extractFunctionDef(sourcePython, numbaFlow.source_astModule)
-	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
-	astFunctionDef = inlineThisFunctionWithTheseValues(astFunctionDef, dictionaryReplacementStatements)
-	ingredientsSequential = IngredientsFunction(astFunctionDef, LedgerOfImports(numbaFlow.source_astModule))
-	ingredientsSequential.astFunctionDef.name = numbaFlow.sequentialCallable
-	ingredientsSequential.astFunctionDef.args = Make.astArgumentsSpecification(args=list_ast_argAnnotated4ArgumentsSpecification)
-	NodeReplacer(
-		findThis = ifThis.isReturn
-		, doThat = Then.replaceWith(Make.astReturn(astTuple4AssignTargetsToFragments))
-			).visit(ingredientsSequential.astFunctionDef)
-	NodeReplacer(
-		findThis = ifThis.isReturn
-		, doThat = Then.replaceWith(Make.astReturn(astTuple4AssignTargetsToFragments))
-			).visit(ingredientsSequential.astFunctionDef)
-	ingredientsSequential.astFunctionDef.returns = astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns
-	replacementMap = [(statement.value, statement.target) for statement in listAnnAssign4DataclassUnpack]
-	ingredientsSequential.astFunctionDef = replaceMatchingASTnodes(
-		ingredientsSequential.astFunctionDef, replacementMap) # type: ignore
-	# TODO a tool to automatically remove unused variables from the ArgumentsSpecification (return, and returns) _might_ be nice.
-	# But, I would need to update the calling function, too.
-	ingredientsSequential = decorateCallableWithNumba(ingredientsSequential)
-
-	ingredientsModuleNumbaUnified = IngredientsModule(
-		ingredientsFunction=[ingredientsInitialize,
-							ingredientsParallel,
-							ingredientsSequential,
-							ingredientsDispatcher], imports=LedgerOfImports(numbaFlow.source_astModule))
-
-	Z0Z_alphaTest_putModuleOnDisk(ingredientsModuleNumbaUnified, numbaFlow)
-
-if __name__ == '__main__':
-	Z0Z_main()