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

mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py

@@ -29,44 +29,30 @@ essential progress feedback capabilities for large-scale computational research.
 """
 
 from astToolkit import (
-	Be, ClassIsAndAttribute, extractFunctionDef, identifierDotAttribute, IngredientsFunction,
-	IngredientsModule, LedgerOfImports, Make, NodeChanger, NodeTourist, Then,
-)
+	Be, extractFunctionDef, identifierDotAttribute, IngredientsFunction, IngredientsModule, LedgerOfImports, Make,
+	NodeChanger, NodeTourist, Then)
 from astToolkit.transformationTools import write_astModule
+from hunterMakesPy import autoDecodingRLE, raiseIfNone
 from mapFolding import getPathFilenameFoldsTotal, MapFoldingState, packageSettings
 from mapFolding.someAssemblyRequired import IfThis
-from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2Numba
-from mapFolding.someAssemblyRequired.toolkitNumba import (
-	decorateCallableWithNumba, parametersNumbaLight, SpicesJobNumba,
-)
+from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
+from mapFolding.someAssemblyRequired.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight, SpicesJobNumba
 from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
 from pathlib import PurePosixPath
-from typing import cast, NamedTuple
-from Z0Z_tools import autoDecodingRLE, raiseIfNone
+from typing import cast, NamedTuple, TYPE_CHECKING
+from typing_extensions import TypeIs
 import ast
 
-# Configuration lists for code optimization and dead code elimination
-listIdentifiersNotUsedAllHARDCODED: list[str] = ['concurrencyLimit', 'foldsTotal', 'mapShape',]
-"""Identifiers that are universally unused across all optimization contexts."""
+if TYPE_CHECKING:
+	from collections.abc import Callable
 
-listIdentifiersNotUsedParallelSequentialHARDCODED: list[str] = ['indexLeaf']
-"""Identifiers unused in both parallel and sequential execution modes."""
+listIdentifiersStaticValuesHARDCODED: list[str] = ['dimensionsTotal', 'leavesTotal']
 
-listIdentifiersNotUsedSequentialHARDCODED: list[str] = ['foldGroups', 'taskDivisions', 'taskIndex',]
-"""Identifiers unused specifically in sequential execution mode."""
-
-listIdentifiersReplacedHARDCODED: list[str] = ['groupsOfFolds',]
-"""Identifiers that get replaced with optimized equivalents during transformation."""
-
-listIdentifiersStaticValuesHARDCODED: list[str] = ['dimensionsTotal', 'leavesTotal',]
-"""Identifiers with compile-time constant values that can be embedded directly."""
-
-listIdentifiersNotUsedHARDCODED: list[str] = listIdentifiersStaticValuesHARDCODED + listIdentifiersReplacedHARDCODED + listIdentifiersNotUsedAllHARDCODED + listIdentifiersNotUsedParallelSequentialHARDCODED + listIdentifiersNotUsedSequentialHARDCODED
-"""Complete list of all identifiers that can be eliminated during optimization."""
-
-def addLauncherNumbaProgress(ingredientsModule: IngredientsModule, ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2Numba, spices: SpicesJobNumba) -> tuple[IngredientsModule, IngredientsFunction]:
+def addLauncherNumbaProgress(ingredientsModule: IngredientsModule, ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2, spices: SpicesJobNumba) -> tuple[IngredientsModule, IngredientsFunction]:
 	"""Add progress tracking capabilities to a Numba-optimized function.
 
+	(AI generated docstring)
+
 	This function modifies both the module and the function to integrate Numba-compatible
 	progress tracking for long-running calculations. It performs several key transformations:
 
@@ -79,16 +65,23 @@ def addLauncherNumbaProgress(ingredientsModule: IngredientsModule, ingredientsFu
 	which can take hours or days to complete, providing visual feedback and
 	estimated completion times.
 
-	Parameters:
-		ingredientsModule: The module where the function is defined.
-		ingredientsFunction: The function to modify with progress tracking.
-		job: Configuration specifying shape details and output paths.
-		spices: Configuration specifying progress bar details.
-
-	Returns:
+	Parameters
+	----------
+	ingredientsModule : IngredientsModule
+		The module where the function is defined.
+	ingredientsFunction : IngredientsFunction
+		The function to modify with progress tracking.
+	job : RecipeJobTheorem2Numba
+		Configuration specifying shape details and output paths.
+	spices : SpicesJobNumba
+		Configuration specifying progress bar details.
+
+	Returns
+	-------
+	moduleAndFunction : tuple[IngredientsModule, IngredientsFunction]
 		Modified module and function with integrated progress tracking capabilities.
-	"""
 
+	"""
 	linesLaunch: str = f"""
 if __name__ == '__main__':
 	with ProgressBar(total={job.foldsTotalEstimated}, update_interval=2) as statusUpdate:
@@ -107,9 +100,9 @@ if __name__ == '__main__':
 	ast_argNumbaProgress = ast.arg(arg=spices.numbaProgressBarIdentifier, annotation=ast.Name(id=numba_progressPythonClass, ctx=ast.Load()))
 	ingredientsFunction.astFunctionDef.args.args.append(ast_argNumbaProgress)
 
-	findThis = ClassIsAndAttribute.targetIs(ast.AugAssign, IfThis.isNameIdentifier(job.shatteredDataclass.countingVariableName.id))
-	doThat = Then.replaceWith(Make.Expr(Make.Call(Make.Attribute(Make.Name(spices.numbaProgressBarIdentifier),'update'),[Make.Constant(1)])))
-	countWithProgressBar = NodeChanger(findThis, doThat)
+	findThis: Callable[[ast.AST], TypeIs[ast.AugAssign] | bool] = Be.AugAssign.targetIs(IfThis.isNameIdentifier(job.shatteredDataclass.countingVariableName.id))
+	doThat: Callable[[ast.AugAssign], ast.Expr] = Then.replaceWith(Make.Expr(Make.Call(Make.Attribute(Make.Name(spices.numbaProgressBarIdentifier),'update'),[Make.Constant(1)])))
+	countWithProgressBar: NodeChanger[ast.AugAssign, ast.Expr] = NodeChanger(findThis, doThat)
 	countWithProgressBar.visit(ingredientsFunction.astFunctionDef)
 
 	removeReturnStatement = NodeChanger(Be.Return, Then.removeIt)
@@ -120,9 +113,11 @@ if __name__ == '__main__':
 
 	return ingredientsModule, ingredientsFunction
 
-def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2Numba) -> IngredientsFunction:
+def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2) -> IngredientsFunction:
 	"""Convert function parameters into initialized variables with concrete values.
 
+	(AI generated docstring)
+
 	This function implements a critical transformation that converts function parameters
 	into statically initialized variables in the function body. This enables several
 	optimizations:
@@ -136,12 +131,18 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 	replacing abstract parameter references with concrete values from the computation state.
 	It also removes unused parameters and variables to eliminate dead code.
 
-	Parameters:
-		ingredientsFunction: The function to transform.
-		job: Recipe containing concrete values for parameters and field metadata.
+	Parameters
+	----------
+	ingredientsFunction : IngredientsFunction
+		The function to transform.
+	job : RecipeJobTheorem2Numba
+		Recipe containing concrete values for parameters and field metadata.
 
-	Returns:
+	Returns
+	-------
+	modifiedFunction : IngredientsFunction
 		The modified function with parameters converted to initialized variables.
+
 	"""
 	ingredientsFunction.imports.update(job.shatteredDataclass.imports)
 
@@ -160,33 +161,35 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 				ImaAnnAssign, elementConstructor = job.shatteredDataclass.Z0Z_field2AnnAssign[ast_arg.arg]
 				match elementConstructor:
 					case 'scalar':
-						cast(ast.Constant, cast(ast.Call, ImaAnnAssign.value).args[0]).value = int(job.state.__dict__[ast_arg.arg])
+						cast('ast.Constant', cast('ast.Call', ImaAnnAssign.value).args[0]).value = int(job.state.__dict__[ast_arg.arg])
 					case 'array':
-						dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[ast_arg.arg], True)
-						dataAs_astExpr: ast.expr = cast(ast.Expr, ast.parse(dataAsStrRLE).body[0]).value
-						cast(ast.Call, ImaAnnAssign.value).args = [dataAs_astExpr]
+						dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[ast_arg.arg], assumeAddSpaces=True)
+						dataAs_astExpr: ast.expr = cast('ast.Expr', ast.parse(dataAsStrRLE).body[0]).value
+						cast('ast.Call', ImaAnnAssign.value).args = [dataAs_astExpr]
 					case _:
 						list_exprDOTannotation: list[ast.expr] = []
 						list_exprDOTvalue: list[ast.expr] = []
 						for dimension in job.state.mapShape:
 							list_exprDOTannotation.append(Make.Name(elementConstructor))
 							list_exprDOTvalue.append(Make.Call(Make.Name(elementConstructor), [Make.Constant(dimension)]))
-						cast(ast.Tuple, cast(ast.Subscript, cast(ast.AnnAssign, ImaAnnAssign).annotation).slice).elts = list_exprDOTannotation
-						cast(ast.Tuple, ImaAnnAssign.value).elts = list_exprDOTvalue
+						cast('ast.Tuple', cast('ast.Subscript', cast('ast.AnnAssign', ImaAnnAssign).annotation).slice).elts = list_exprDOTannotation
+						cast('ast.Tuple', ImaAnnAssign.value).elts = list_exprDOTvalue
 
 				ingredientsFunction.astFunctionDef.body.insert(0, ImaAnnAssign)
 
-			findThis = IfThis.is_argIdentifier(ast_arg.arg)
-			remove_arg = NodeChanger(findThis, Then.removeIt)
+			findThis: Callable[[ast.AST], TypeIs[ast.arg] | bool] = IfThis.is_argIdentifier(ast_arg.arg)
+			remove_arg: NodeChanger[ast.arg, None] = NodeChanger(findThis, Then.removeIt)
 			remove_arg.visit(ingredientsFunction.astFunctionDef)
 
 	ast.fix_missing_locations(ingredientsFunction.astFunctionDef)
 	return ingredientsFunction
 
-def makeJobNumba(job: RecipeJobTheorem2Numba, spices: SpicesJobNumba) -> None:
+def makeJobNumba(job: RecipeJobTheorem2, spices: SpicesJobNumba) -> None:
 	"""Generate an optimized Numba-compiled computation module for map folding calculations.
 
-	This function orchestrates the complete code transformation pipeline to convert
+	(AI generated docstring)
+
+	This function orchestrates the complete code transformation assembly line to convert
 	a generic map folding algorithm into a highly optimized, specialized computation
 	module. The transformation process includes:
 
@@ -203,26 +206,21 @@ def makeJobNumba(job: RecipeJobTheorem2Numba, spices: SpicesJobNumba) -> None:
 	map folding calculations for the specific map dimensions with maximum
 	performance through just-in-time compilation.
 
-	Parameters:
-		job: Configuration recipe containing source locations, target paths, and state.
-		spices: Optimization settings including Numba parameters and progress options.
-	"""
+	Parameters
+	----------
+	job : RecipeJobTheorem2Numba
+		Configuration recipe containing source locations, target paths, and state.
+	spices : SpicesJobNumba
+		Optimization settings including Numba parameters and progress options.
 
+	"""
 	astFunctionDef: ast.FunctionDef = raiseIfNone(extractFunctionDef(job.source_astModule, job.countCallable))
 	ingredientsCount: IngredientsFunction = IngredientsFunction(astFunctionDef, LedgerOfImports())
 
-	# Remove `foldGroups` and any other unused statements, so you can dynamically determine which variables are not used
-	findThis = ClassIsAndAttribute.targetsIs(ast.Assign, lambda list_expr: any([IfThis.isSubscriptIdentifier('foldGroups')(node) for node in list_expr ]))
-	# findThis = IfThis.isAssignAndTargets0Is(IfThis.isSubscriptIdentifier('foldGroups'))
-	doThat = Then.removeIt
-	remove_foldGroups = NodeChanger(findThis, doThat)
-	# remove_foldGroups.visit(ingredientsCount.astFunctionDef)
-
-	# replace identifiers with static values with their values, so you can dynamically determine which variables are not used
 	listIdentifiersStaticValues: list[str] = listIdentifiersStaticValuesHARDCODED
 	for identifier in listIdentifiersStaticValues:
-		findThis = IfThis.isNameIdentifier(identifier)
-		doThat = Then.replaceWith(Make.Constant(int(job.state.__dict__[identifier])))
+		findThis: Callable[[ast.AST], TypeIs[ast.Name] | bool] = IfThis.isNameIdentifier(identifier)
+		doThat: Callable[[ast.Name], ast.Constant] = Then.replaceWith(Make.Constant(int(job.state.__dict__[identifier])))
 		NodeChanger(findThis, doThat).visit(ingredientsCount.astFunctionDef)
 
 	ingredientsModule = IngredientsModule()
@@ -242,8 +240,8 @@ if __name__ == '__main__':
 	writeStream.write(str(foldsTotal))
 	writeStream.close()
 """
-	# from mapFolding.oeis import getFoldsTotalKnown
-	# print(foldsTotal == getFoldsTotalKnown({job.state.mapShape}))
+	# from mapFolding.oeis import getFoldsTotalKnown  # noqa: ERA001
+	# print(foldsTotal == getFoldsTotalKnown({job.state.mapShape}))  # noqa: ERA001
 		ingredientsModule.appendLauncher(ast.parse(linesLaunch))
 		changeReturnParallelCallable = NodeChanger(Be.Return, Then.replaceWith(Make.Return(job.shatteredDataclass.countingVariableName)))
 		changeReturnParallelCallable.visit(ingredientsCount.astFunctionDef)
@@ -258,12 +256,18 @@ if __name__ == '__main__':
 		generation. Each configuration specifies the source module, target type name,
 		and optional import alias for the transformation.
 
-		Attributes:
-			fml: Framework datatype identifier to be replaced.
-			Z0Z_module: Module containing the target datatype (e.g., 'numba', 'numpy').
-			Z0Z_type_name: Concrete type name in the target module.
-			Z0Z_asname: Optional import alias for the type.
+		Attributes
+		----------
+		fml : str
+			Framework datatype identifier to be replaced.
+		Z0Z_module : identifierDotAttribute
+			Module containing the target datatype (e.g., 'numba', 'numpy').
+		Z0Z_type_name : str
+			Concrete type name in the target module.
+		Z0Z_asname : str | None = None
+			Optional import alias for the type.
 		"""
+
 		fml: str
 		Z0Z_module: identifierDotAttribute
 		Z0Z_type_name: str
@@ -283,7 +287,7 @@ if __name__ == '__main__':
 		)
 		ingredientsModule.appendPrologue(statement=statement)
 
-	ingredientsCount.imports.removeImportFromModule('mapFolding.theSSOT')
+	ingredientsCount.imports.removeImportFromModule('mapFolding.dataBaskets')
 
 	listNumPyTypeConfigs = [
 		DatatypeConfig(fml='Array1DLeavesTotal', Z0Z_module='numpy', Z0Z_type_name='uint8', Z0Z_asname='Array1DLeavesTotal'),
@@ -296,7 +300,6 @@ if __name__ == '__main__':
 		ingredientsCount.imports.addImportFrom_asStr(typeConfig.Z0Z_module, typeConfig.Z0Z_type_name, typeConfig.Z0Z_asname)
 
 	ingredientsCount.astFunctionDef.decorator_list = [] # TODO low-priority, handle this more elegantly
-	# TODO when I add the function signature in numba style back to the decorator, the logic needs to handle `ProgressBarType:`
 	ingredientsCount = decorateCallableWithNumba(ingredientsCount, spices.parametersNumba)
 	ingredientsModule.appendIngredientsFunction(ingredientsCount)
 	write_astModule(ingredientsModule, job.pathFilenameModule, job.packageIdentifier)
@@ -323,15 +326,11 @@ if __name__ == '__main__':
 	"""
 
 if __name__ == '__main__':
-	mapShape = (2,4)
-	state = MapFoldingState(mapShape)
-	state = initializeGroupsOfFolds(state)
-	# foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal
-	# foldsTotalEstimated = dictionaryEstimates[state.mapShape] // state.leavesTotal
-	foldsTotalEstimated = 0
+	state = initializeGroupsOfFolds(MapFoldingState((2,4)))
 	pathModule = PurePosixPath(packageSettings.pathPackage, 'jobs')
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
-	aJob = RecipeJobTheorem2Numba(state, foldsTotalEstimated, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
+	aJob = RecipeJobTheorem2(state, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
 	spices = SpicesJobNumba(useNumbaProgressBar=False, parametersNumba=parametersNumbaLight)
-	# spices = SpicesJobNumba()
 	makeJobNumba(aJob, spices)
+
+# TODO Improve this module with lessons learned in `makeJobTheorem2codon`.

mapFolding/someAssemblyRequired/makeJobTheorem2codon.py

@@ -0,0 +1,256 @@
+"""codon.
+
+https://docs.exaloop.io/start/install/"""
+
+from astToolkit import (
+	Be, DOT, extractFunctionDef, Grab, hasDOTvalue, identifierDotAttribute, IngredientsFunction, IngredientsModule, Make,
+	NodeChanger, NodeTourist, Then)
+from astToolkit.transformationTools import write_astModule
+from hunterMakesPy import autoDecodingRLE, raiseIfNone
+from mapFolding import getPathFilenameFoldsTotal, MapFoldingState, packageSettings
+from mapFolding.someAssemblyRequired import IfThis
+from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
+from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
+from pathlib import Path, PurePosixPath
+from typing import cast, NamedTuple
+import ast
+import subprocess
+import sys
+
+class DatatypeConfiguration(NamedTuple):
+	"""Configuration for mapping framework datatypes to compiled datatypes.
+
+	This configuration class defines how abstract datatypes used in the map folding framework should be replaced with compiled
+	datatypes during code generation. Each configuration specifies the source module, target type name, and optional import
+	alias for the transformation.
+
+	Attributes
+	----------
+	datatypeIdentifier : str
+		Framework datatype identifier to be replaced.
+	typeModule : identifierDotAttribute
+		Module containing the target datatype (e.g., 'codon', 'numpy').
+	typeIdentifier : str
+		Concrete type name in the target module.
+	type_asname : str | None = None
+		Optional import alias for the type.
+	"""
+
+	datatypeIdentifier: str
+	typeModule: identifierDotAttribute
+	typeIdentifier: str
+	type_asname: str | None = None
+
+# TODO replace with dynamic system. Probably use `Final` in the dataclass.
+listIdentifiersStaticValuesHARDCODED: list[str] = ['dimensionsTotal', 'leavesTotal']
+
+listDatatypeConfigs: list[DatatypeConfiguration] = [
+	DatatypeConfiguration(datatypeIdentifier='DatatypeLeavesTotal', typeModule='numpy', typeIdentifier='uint16', type_asname='DatatypeLeavesTotal'),
+	DatatypeConfiguration(datatypeIdentifier='DatatypeElephino', typeModule='numpy', typeIdentifier='uint16', type_asname='DatatypeElephino'),
+	DatatypeConfiguration(datatypeIdentifier='DatatypeFoldsTotal', typeModule='numpy', typeIdentifier='int64', type_asname='DatatypeFoldsTotal'),
+]
+
+listNumPyTypeConfigs: list[DatatypeConfiguration] = [
+	DatatypeConfiguration(datatypeIdentifier='Array1DLeavesTotal', typeModule='numpy', typeIdentifier='uint16', type_asname='Array1DLeavesTotal'),
+	DatatypeConfiguration(datatypeIdentifier='Array1DElephino', typeModule='numpy', typeIdentifier='uint16', type_asname='Array1DElephino'),
+	DatatypeConfiguration(datatypeIdentifier='Array3D', typeModule='numpy', typeIdentifier='uint16', type_asname='Array3D'),
+]
+
+def _datatypeDefinitions(ingredientsFunction: IngredientsFunction, ingredientsModule: IngredientsModule) -> tuple[IngredientsFunction, IngredientsModule]:
+	for datatypeConfig in listDatatypeConfigs:
+		ingredientsFunction.imports.removeImportFrom(datatypeConfig.typeModule, None, datatypeConfig.datatypeIdentifier)
+		ingredientsFunction.imports.addImportFrom_asStr(datatypeConfig.typeModule, datatypeConfig.typeIdentifier, datatypeConfig.type_asname)
+		continue
+		ingredientsModule.appendPrologue(statement=Make.Assign([Make.Name(datatypeConfig.datatypeIdentifier, ast.Store())]
+			, value=Make.Name(datatypeConfig.typeIdentifier)
+		))
+
+	for datatypeConfig in listNumPyTypeConfigs:
+		ingredientsFunction.imports.removeImportFrom(datatypeConfig.typeModule, None, datatypeConfig.datatypeIdentifier)
+		ingredientsFunction.imports.addImportFrom_asStr(datatypeConfig.typeModule, datatypeConfig.typeIdentifier, datatypeConfig.type_asname)
+		continue
+		ingredientsModule.appendPrologue(statement=Make.Assign([Make.Name(datatypeConfig.datatypeIdentifier, ast.Store())]
+			, value=Make.Name(datatypeConfig.typeIdentifier)
+		))
+
+	ingredientsFunction.imports.removeImportFromModule('mapFolding.dataBaskets')
+
+	return ingredientsFunction, ingredientsModule
+
+def _pythonCode2expr(string: str) -> ast.expr:
+	"""Convert *one* expression as a string of Python code to an `ast.expr`."""
+	return raiseIfNone(NodeTourist(Be.Expr, Then.extractIt(DOT.value)).captureLastMatch(ast.parse(string)))
+
+def _variableCompatibility(ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2) -> IngredientsFunction:
+	for ast_arg in job.shatteredDataclass.list_argAnnotated4ArgumentsSpecification:
+		identifier = ast_arg.arg
+		annotation = raiseIfNone(ast_arg.annotation)
+
+		# `identifier` in Augmented Assignment.
+		NodeChanger(Be.AugAssign.targetIs(IfThis.isNestedNameIdentifier(identifier))
+			, doThat=lambda node: Grab.valueAttribute(Then.replaceWith(Make.Call(annotation, listParameters=[node.value])))(node)
+		).visit(ingredientsFunction.astFunctionDef)
+
+		# `identifier` in Assignments; exclude `numpy.array`.
+		NodeChanger(findThis=lambda node: IfThis.isAssignAndTargets0Is(IfThis.isNameIdentifier(identifier))(node)
+			and Be.Assign.valueIs(Be.Constant)(node)
+			, doThat=lambda node: Grab.valueAttribute(Then.replaceWith(Make.Call(annotation, listParameters=[node.value])))(node)
+		).visit(ingredientsFunction.astFunctionDef)
+
+		# `identifier` - 1.
+		NodeChanger(Be.BinOp.leftIs(IfThis.isNestedNameIdentifier(identifier))
+			, doThat=lambda node: Grab.rightAttribute(Then.replaceWith(Make.Call(annotation, listParameters=[node.right])))(node)
+		).visit(ingredientsFunction.astFunctionDef)
+
+		# `identifier` in Comparison.
+		NodeChanger(Be.Compare.leftIs(IfThis.isNestedNameIdentifier(identifier))
+			, doThat=lambda node: Grab.comparatorsAttribute(lambda at: Then.replaceWith([Make.Call(annotation, listParameters=[node.comparators[0]])])(at[0]))(node)
+		).visit(ingredientsFunction.astFunctionDef)
+
+		# `identifier` has exactly one index value.
+		NodeChanger(
+			findThis=lambda node: Be.Subscript.valueIs(IfThis.isNestedNameIdentifier(identifier))(node)
+			and not Be.Subscript.sliceIs(Be.Tuple)(node)
+			, doThat=lambda node: Grab.sliceAttribute(Then.replaceWith(Make.Call(Make.Name('int'), listParameters=[node.slice])))(node)
+		).visit(ingredientsFunction.astFunctionDef)
+
+		# `identifier` has multiple index values.
+		NodeChanger(
+			findThis=lambda node: Be.Subscript.valueIs(IfThis.isNestedNameIdentifier(identifier))(node)
+			and Be.Subscript.sliceIs(Be.Tuple)(node)
+			, doThat=lambda node: Grab.sliceAttribute(Grab.eltsAttribute(
+				Then.replaceWith([
+					Make.Call(Make.Name('int'), listParameters=[cast(ast.Tuple, node.slice).elts[index]])
+					for index in range(len(cast(ast.Tuple, node.slice).elts))
+					])
+			))(node)
+		).visit(ingredientsFunction.astFunctionDef)
+
+	return ingredientsFunction
+
+def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2) -> IngredientsFunction:
+	"""Convert function parameters into initialized variables with concrete values.
+
+	This function converts function arguments into statically initialized variables in the function body.
+
+	The function handles different data types (scalars, arrays, custom types) appropriately, replacing abstract parameter
+	references with concrete values from the computation state. It also removes unused parameters and variables.
+
+	Parameters
+	----------
+	ingredientsFunction : IngredientsFunction
+		The function to transform.
+	job : RecipeJobTheorem2
+		Recipe containing concrete values for parameters and field metadata.
+
+	Returns
+	-------
+	modifiedFunction : IngredientsFunction
+		The modified function with parameters converted to initialized variables.
+
+	"""
+	ingredientsFunction.imports.update(job.shatteredDataclass.imports)
+
+	list_argCuzMyBrainRefusesToThink: list[ast.arg] = ingredientsFunction.astFunctionDef.args.args + ingredientsFunction.astFunctionDef.args.posonlyargs + ingredientsFunction.astFunctionDef.args.kwonlyargs
+	list_arg_arg: list[str] = [ast_arg.arg for ast_arg in list_argCuzMyBrainRefusesToThink]
+	listName: list[ast.Name] = []
+	NodeTourist(Be.Name, Then.appendTo(listName)).visit(ingredientsFunction.astFunctionDef)
+	listIdentifiers: list[str] = [astName.id for astName in listName]
+	listIdentifiersNotUsed: list[str] = list(set(list_arg_arg) - set(listIdentifiers))
+
+	for ast_arg in list_argCuzMyBrainRefusesToThink:
+		if ast_arg.arg in job.shatteredDataclass.field2AnnAssign:
+			if ast_arg.arg in listIdentifiersNotUsed:
+				pass
+			else:
+				Ima___Assign, elementConstructor = job.shatteredDataclass.Z0Z_field2AnnAssign[ast_arg.arg]
+				match elementConstructor:
+					case 'scalar':
+						cast('ast.Constant', cast('ast.Call', Ima___Assign.value).args[0]).value = int(job.state.__dict__[ast_arg.arg])
+					case 'array':
+						dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[ast_arg.arg], assumeAddSpaces=True)
+						dataAs_ast_expr: ast.expr = _pythonCode2expr(dataAsStrRLE)
+						cast('ast.Call', Ima___Assign.value).args = [dataAs_ast_expr]
+					case _:
+						pass
+
+				ingredientsFunction.astFunctionDef.body.insert(0, Ima___Assign)
+
+			NodeChanger(IfThis.is_argIdentifier(ast_arg.arg), Then.removeIt).visit(ingredientsFunction.astFunctionDef)
+
+	ast.fix_missing_locations(ingredientsFunction.astFunctionDef)
+	return ingredientsFunction
+
+def makeJob(job: RecipeJobTheorem2) -> None:
+	"""Generate an optimized module for map folding calculations.
+
+	This function orchestrates the complete code transformation assembly line to convert
+	a generic map folding algorithm into a highly optimized, specialized computation
+	module.
+
+	Parameters
+	----------
+	job : RecipeJobTheorem2
+		Configuration recipe containing source locations, target paths, and state.
+
+	"""
+	ingredientsCount: IngredientsFunction = IngredientsFunction(raiseIfNone(extractFunctionDef(job.source_astModule, job.countCallable)))
+	ingredientsCount.astFunctionDef.decorator_list = []
+
+	# Replace identifiers-with-static-values with their values.
+	listIdentifiersStaticValues: list[str] = listIdentifiersStaticValuesHARDCODED
+	for identifier in listIdentifiersStaticValues:
+		NodeChanger(IfThis.isNameIdentifier(identifier)
+			, Then.replaceWith(Make.Constant(int(job.state.__dict__[identifier])))
+		).visit(ingredientsCount.astFunctionDef)
+
+	linesLaunch: str = f"""
+if __name__ == '__main__':
+	foldsTotal = {job.countCallable}()
+	print('\\nmap {job.state.mapShape} =', foldsTotal)
+	writeStream = open('{job.pathFilenameFoldsTotal.as_posix()}', 'w')
+	writeStream.write(str(foldsTotal))
+	writeStream.close()
+"""
+	ingredientsModule = IngredientsModule(launcher=ast.parse(linesLaunch))
+
+	# TODO think about `groupsOfFolds *= DatatypeFoldsTotal({2 * job.state.leavesTotal}); return groupsOfFolds`
+	NodeChanger(Be.Return
+		, Then.replaceWith(Make.Return(job.shatteredDataclass.countingVariableName))).visit(ingredientsCount.astFunctionDef)
+	groupsOfFolds2foldsTotal = NodeChanger[ast.AugAssign, hasDOTvalue](
+		findThis=(lambda node: Be.AugAssign.targetIs(IfThis.isNameIdentifier(job.shatteredDataclass.countingVariableName.id))(node)
+			and Be.AugAssign.opIs(Be.Mult)(node)
+			and Be.AugAssign.valueIs(Be.Constant)(node)
+		)
+		, doThat=lambda node: Grab.valueAttribute(Then.replaceWith(Make.Constant(job.state.leavesTotal * ast.literal_eval(node.value))))(node)
+	)
+	groupsOfFolds2foldsTotal.visit(ingredientsCount.astFunctionDef)
+
+	# TODO think about assigning `returns` here, then removing `returns` a few lines from now.
+	ingredientsCount.astFunctionDef.returns = job.shatteredDataclass.countingVariableAnnotation
+
+	ingredientsCount = move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsCount, job)
+
+	ingredientsCount, ingredientsModule = _datatypeDefinitions(ingredientsCount, ingredientsModule)
+	# NOTE Reminder, `returns = None` means "type information is null"; the identifier for the return was removed by `_datatypeDefinitions`.
+	ingredientsCount.astFunctionDef.returns = None
+
+	ingredientsCount = _variableCompatibility(ingredientsCount, job)
+
+	ingredientsModule.appendIngredientsFunction(ingredientsCount)
+	write_astModule(ingredientsModule, pathFilename=job.pathFilenameModule, packageName=job.packageIdentifier)
+
+	if sys.platform == 'linux':
+		pathFilenameBuild = Path.home() / 'mapFolding' / 'jobs' / job.pathFilenameModule.stem
+		pathFilenameBuild.parent.mkdir(parents=True, exist_ok=True)
+
+		buildCommand = ['codon', 'build', '-release', '-disable-exceptions', '-o', str(pathFilenameBuild), str(job.pathFilenameModule)]
+		subprocess.run(buildCommand)
+
+if __name__ == '__main__':
+	state = initializeGroupsOfFolds(MapFoldingState((2,4)))
+	pathModule = PurePosixPath(packageSettings.pathPackage, 'jobs')
+	# TODO put `pathFilenameFoldsTotal` in wsl.
+	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
+	aJob = RecipeJobTheorem2(state, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
+	makeJob(aJob)