mapFolding 0.13.0__tar.gz → 0.13.1__tar.gz

{mapfolding-0.13.0 → mapfolding-0.13.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.13.0
+Version: 0.13.1
 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

{mapfolding-0.13.0 → mapfolding-0.13.1}/mapFolding/someAssemblyRequired/RecipeJob.py

@@ -9,7 +9,6 @@ from mapFolding import (
 from mapFolding.someAssemblyRequired import dataclassInstanceIdentifierDEFAULT, ShatteredDataclass
 from mapFolding.someAssemblyRequired.transformationTools import shatter_dataclassesDOTdataclass
 from pathlib import Path, PurePosixPath
-from typing import TypeAlias
 import dataclasses
 
 @dataclasses.dataclass
@@ -134,11 +133,11 @@ class RecipeJobTheorem2:
 	"""Logical path to target dataclass module."""
 
 	# Datatypes ------------------------------------------
-	DatatypeFoldsTotal: TypeAlias = TheDatatypeFoldsTotal
+	type DatatypeFoldsTotal = TheDatatypeFoldsTotal
 	"""Type alias for datatype linked to the magnitude of `foldsTotal`."""
-	DatatypeElephino: TypeAlias = TheDatatypeElephino
+	type DatatypeElephino = TheDatatypeElephino
 	"""Type alias for intermediate computation datatype."""
-	DatatypeLeavesTotal: TypeAlias = TheDatatypeLeavesTotal
+	type DatatypeLeavesTotal = TheDatatypeLeavesTotal
 	"""Type alias for datatype linked to the magnitude of `leavesTotal`."""
 
 	def _makePathFilename(self, pathRoot: PurePosixPath | None = None, logicalPathINFIX: identifierDotAttribute | None = None, filenameStem: str | None = None, fileExtension: str | None = None) -> PurePosixPath:

{mapfolding-0.13.0 → mapfolding-0.13.1}/mapFolding/someAssemblyRequired/_toolkitContainers.py

@@ -217,10 +217,10 @@ class DeReConstructField2ast:
 		self.ast_keyword_field__field = Make.keyword(self.name, self.astName)
 		self.ast_nameDOTname = Make.Attribute(Make.Name(dataclassesDOTdataclassInstanceIdentifier), self.name)
 
-		self.astAnnotation = raiseIfNone(NodeTourist[ast.AnnAssign, ast.Name | None](
+		self.astAnnotation = cast('ast.Name', raiseIfNone(NodeTourist(
 			findThis = Be.AnnAssign.targetIs(IfThis.isNameIdentifier(self.name))
-			, doThat = Then.extractIt(cast("Callable[[ast.AnnAssign], ast.Name | None]", DOT.annotation))
-			).captureLastMatch(dataclassClassDef))
+			, doThat = Then.extractIt(DOT.annotation)
+			).captureLastMatch(dataclassClassDef)))
 
 		self.ast_argAnnotated = Make.arg(self.name, self.astAnnotation)
 

{mapfolding-0.13.0 → mapfolding-0.13.1}/mapFolding/someAssemblyRequired/makeAllModules.py

@@ -299,7 +299,7 @@ def makeDaoOfMapFolding(astModule: ast.Module, moduleIdentifier: str, callableId
 		ingredientsFunctionDispatcher.imports.update(shatteredDataclass.imports)
 		targetCallableIdentifier = ingredientsFunction.astFunctionDef.name
 		ingredientsFunctionDispatcher = unpackDataclassCallFunctionRepackDataclass(ingredientsFunctionDispatcher, targetCallableIdentifier, shatteredDataclass)
-		astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist[ast.Return, ast.expr | None](Be.Return.valueIs(Be.Tuple)
+		astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist(Be.Return.valueIs(Be.Tuple)
 				, doThat=Then.extractIt(DOT.value)).captureLastMatch(ingredientsFunction.astFunctionDef)))
 		astTuple.ctx = ast.Store()
 
@@ -743,7 +743,7 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom) -> None:
 	targetCallableIdentifier = astImportFrom.names[0].name
 	ingredientsFunction = raiseIfNone(unpackDataclassCallFunctionRepackDataclass(ingredientsFunction, targetCallableIdentifier, shatteredDataclass))
 	targetFunctionDef: ast.FunctionDef = raiseIfNone(extractFunctionDef(parseLogicalPath2astModule(raiseIfNone(astImportFrom.module)), targetCallableIdentifier))
-	astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist[ast.Return, ast.expr | None](Be.Return.valueIs(Be.Tuple)
+	astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist(Be.Return.valueIs(Be.Tuple)
 			, doThat=Then.extractIt(DOT.value)).captureLastMatch(targetFunctionDef)))
 	astTuple.ctx = ast.Store()
 

mapfolding-0.13.1/mapFolding/someAssemblyRequired/makeJobTheorem2codon.py

@@ -0,0 +1,196 @@
+"""codon.
+
+https://docs.exaloop.io/start/install/
+"""
+
+from astToolkit import (
+	Be, DOT, extractFunctionDef, Grab, identifierDotAttribute, IngredientsFunction, IngredientsModule, Make, NodeChanger,
+	NodeTourist, Then)
+from astToolkit.transformationTools import removeUnusedParameters, write_astModule
+from hunterMakesPy import autoDecodingRLE, raiseIfNone
+from mapFolding import getPathFilenameFoldsTotal, MapFoldingState
+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']
+
+listDatatypeConfigurations: 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'),
+]
+
+listNumPy_dtype: 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 _addWriteFoldsTotal(ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2) -> IngredientsFunction:
+	NodeChanger(Be.Return, Then.removeIt).visit(ingredientsFunction.astFunctionDef)
+	ingredientsFunction.astFunctionDef.returns = Make.Constant(None)
+
+	writeFoldsTotal = Make.Expr(Make.Call(Make.Attribute(
+		Make.Call(Make.Name('open'), listParameters=[Make.Constant(str(job.pathFilenameFoldsTotal.as_posix())), Make.Constant('w')])
+		, 'write'), listParameters=[Make.Call(Make.Name('str'), listParameters=[
+			Make.Mult().join([job.shatteredDataclass.countingVariableName, Make.Constant(job.state.leavesTotal * 2)])])]))
+
+	NodeChanger(IfThis.isAllOf(Be.AugAssign.targetIs(IfThis.isNameIdentifier(job.shatteredDataclass.countingVariableName.id))
+			, Be.AugAssign.opIs(Be.Mult), Be.AugAssign.valueIs(Be.Constant))
+		, doThat=Then.replaceWith(writeFoldsTotal)
+	).visit(ingredientsFunction.astFunctionDef)
+
+	return ingredientsFunction
+
+def _datatypeDefinitions(ingredientsFunction: IngredientsFunction, ingredientsModule: IngredientsModule) -> tuple[IngredientsFunction, IngredientsModule]:
+	for datatypeConfig in [*listDatatypeConfigurations, *listNumPy_dtype]:
+		ingredientsFunction.imports.removeImportFrom(datatypeConfig.typeModule, None, datatypeConfig.datatypeIdentifier)
+		ingredientsFunction.imports.addImportFrom_asStr(datatypeConfig.typeModule, datatypeConfig.typeIdentifier, datatypeConfig.type_asname)
+
+	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:
+	# On some assignment or comparison values, add a type constructor to ensure compatibility.
+	# On some values-as-indexer, add a type constructor to ensure indexing-method compatibility.
+	for ast_arg in job.shatteredDataclass.list_argAnnotated4ArgumentsSpecification:
+		identifier = ast_arg.arg
+		annotation = raiseIfNone(ast_arg.annotation)
+
+		# `identifier` in Augmented Assignment, or in Assignments and value is Constant.
+		NodeChanger(findThis=IfThis.isAnyOf(
+				Be.AugAssign.targetIs(IfThis.isNestedNameIdentifier(identifier))
+				, IfThis.isAllOf(IfThis.isAssignAndTargets0Is(IfThis.isNameIdentifier(identifier))
+					, Be.Assign.valueIs(Be.Constant))
+			)
+			, doThat=lambda node, annotation=annotation: 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, annotation=annotation: 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, annotation=annotation: Grab.comparatorsAttribute(lambda at, annotation=annotation: Then.replaceWith([Make.Call(annotation, listParameters=[node.comparators[0]])])(at[0]))(node)
+		).visit(ingredientsFunction.astFunctionDef)
+
+		# `identifier` has exactly one index value.
+		NodeChanger(IfThis.isAllOf(Be.Subscript.valueIs(IfThis.isNestedNameIdentifier(identifier))
+			, lambda node: 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(IfThis.isAllOf(Be.Subscript.valueIs(IfThis.isNestedNameIdentifier(identifier))
+			, Be.Subscript.sliceIs(Be.Tuple))
+			, 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_arg2body(identifier: str, job: RecipeJobTheorem2) -> ast.AnnAssign | ast.Assign:
+	Ima___Assign, elementConstructor = job.shatteredDataclass.Z0Z_field2AnnAssign[identifier]
+	match elementConstructor:
+		case 'scalar':
+			cast('ast.Constant', cast('ast.Call', Ima___Assign.value).args[0]).value = int(job.state.__dict__[identifier])
+		case 'array':
+			dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[identifier], assumeAddSpaces=True)
+			dataAs_ast_expr: ast.expr = _pythonCode2expr(dataAsStrRLE)
+			cast('ast.Call', Ima___Assign.value).args = [dataAs_ast_expr]
+		case _:
+			pass
+	return Ima___Assign
+
+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)
+
+	ingredientsCount.imports.update(job.shatteredDataclass.imports)
+	ingredientsCount = removeUnusedParameters(ingredientsCount)
+	NodeChanger(Be.arg, lambda removeIt: ingredientsCount.astFunctionDef.body.insert(0, _move_arg2body(removeIt.arg, job))).visit(ingredientsCount.astFunctionDef)
+
+	ingredientsCount = _addWriteFoldsTotal(ingredientsCount, job)
+	ingredientsCount = _variableCompatibility(ingredientsCount, job)
+
+	ingredientsModule = IngredientsModule(launcher=Make.Module([
+		Make.If(Make.Compare(Make.Name('__name__'), [Make.Eq()], [Make.Constant('__main__')])
+			, body=[Make.Expr(Make.Call(Make.Name(job.countCallable)))])]))
+
+	ingredientsCount, ingredientsModule = _datatypeDefinitions(ingredientsCount, ingredientsModule)
+
+	ingredientsModule.appendIngredientsFunction(ingredientsCount)
+	write_astModule(ingredientsModule, pathFilename=job.pathFilenameModule, packageName=job.packageIdentifier)
+
+	if sys.platform == 'linux':
+		buildCommand: list[str] = ['codon', 'build', '--exe', '--release',
+			'--fast-math', '--enable-unsafe-fp-math', '--disable-exceptions',
+			str(job.pathFilenameModule)]
+		subprocess.run(buildCommand, check=False)
+		subprocess.run(['/usr/bin/strip', str(job.pathFilenameModule.with_suffix(''))], check=False)
+
+if __name__ == '__main__':
+	state = initializeGroupsOfFolds(MapFoldingState((2,4)))
+	pathModule = PurePosixPath(Path.home(), 'mapFolding', 'jobs')
+	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
+	aJob = RecipeJobTheorem2(state, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
+	makeJob(aJob)

{mapfolding-0.13.0 → mapfolding-0.13.1}/mapFolding/someAssemblyRequired/toolkitNumba.py

@@ -26,7 +26,9 @@ system to produce standalone modules optimized for specific map dimensions and c
 """
 
 from astToolkit import identifierDotAttribute, IngredientsFunction, Make
-from typing import cast, Final, NotRequired, TYPE_CHECKING, TypedDict
+from collections.abc import Callable
+from numba.core.compiler import CompilerBase as numbaCompilerBase
+from typing import Any, Final, NotRequired, TYPE_CHECKING, TypedDict
 import ast
 import dataclasses
 import warnings
@@ -69,7 +71,7 @@ class ParametersNumba(TypedDict):
 	forceinline: NotRequired[bool]
 	forceobj: NotRequired[bool]
 	inline: NotRequired[str]
-	# locals: NotRequired[dict[str, Any]]
+	locals: NotRequired[dict[str, Any]]
 	looplift: NotRequired[bool]
 	no_cfunc_wrapper: NotRequired[bool]
 	no_cpython_wrapper: NotRequired[bool]
@@ -77,8 +79,8 @@ class ParametersNumba(TypedDict):
 	nogil: NotRequired[bool]
 	nopython: NotRequired[bool]
 	parallel: NotRequired[bool]
-	# pipeline_class: NotRequired[type[numbaCompilerBase]]
-	# signature_or_function: NotRequired[Any | Callable[..., Any] | str | tuple[Any, ...]]
+	pipeline_class: NotRequired[type[numbaCompilerBase]]
+	signature_or_function: NotRequired[Any | Callable[..., Any] | str | tuple[Any, ...]]
 	target: NotRequired[str]
 
 parametersNumbaDefault: Final[ParametersNumba] = { '_nrt': True, 'boundscheck': False, 'cache': True, 'error_model': 'numpy', 'fastmath': True, 'forceinline': True, 'inline': 'always', 'looplift': False, 'no_cfunc_wrapper': False, 'no_cpython_wrapper': False, 'nopython': True, 'parallel': False }
@@ -257,10 +259,10 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 
 	if ingredientsFunction.astFunctionDef.returns and isinstance(ingredientsFunction.astFunctionDef.returns, ast.Name):
 		theReturn: ast.Name = ingredientsFunction.astFunctionDef.returns
-		list_argsDecorator = [cast("ast.expr", Make.Call(Make.Name(theReturn.id)
-							, list_arg4signature_or_function if list_arg4signature_or_function else [], [] ) )]
+		list_argsDecorator = [Make.Call(Make.Name(theReturn.id)
+							, list_arg4signature_or_function if list_arg4signature_or_function else [], [] )]
 	elif list_arg4signature_or_function:
-		list_argsDecorator = [cast("ast.expr", Make.Tuple(list_arg4signature_or_function))]
+		list_argsDecorator = [Make.Tuple(list_arg4signature_or_function)]
 
 	ingredientsFunction.astFunctionDef = Z0Z_UnhandledDecorators(ingredientsFunction.astFunctionDef)
 	if parametersNumba is None:

{mapfolding-0.13.0 → mapfolding-0.13.1}/mapFolding.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.13.0
+Version: 0.13.1
 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

{mapfolding-0.13.0 → mapfolding-0.13.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mapFolding"
-version = "0.13.0"
+version = "0.13.1"
 description = "Map folding algorithm with code transformation framework for optimizing numerical computations."
 readme = "README.md"
 requires-python = ">=3.12"

mapfolding-0.13.0/mapFolding/someAssemblyRequired/makeJobTheorem2codon.py

@@ -1,256 +0,0 @@
-"""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)