mapFolding 0.16.2__py3-none-any.whl → 0.17.0__py3-none-any.whl

mapFolding/someAssemblyRequired/_toolkitContainers.py

@@ -25,12 +25,13 @@ to low-level optimized functions while maintaining semantic equivalence and type
 the compilation process.
 """
 
-from astToolkit import Be, DOT, identifierDotAttribute, LedgerOfImports, Make, NodeTourist, Then
+from astToolkit import Be, DOT, identifierDotAttribute, Make, NodeTourist, Then
+from astToolkit.containers import LedgerOfImports
 from collections.abc import Callable
 from copy import deepcopy
 from hunterMakesPy import raiseIfNone
 from mapFolding.someAssemblyRequired import IfThis
-from typing import Any, cast
+from typing import Any, cast, NamedTuple
 import ast
 import dataclasses
 
@@ -39,7 +40,7 @@ dummySubscript = Make.Subscript(Make.Name("dummy"), Make.Name("slice"))
 dummyTuple = Make.Tuple([Make.Name("dummyElement")])
 
 @dataclasses.dataclass
-class ShatteredDataclass:
+class ShatteredDataclass: # slots?
 	"""Container for decomposed dataclass components organized as AST nodes for code generation.
 
 	This class holds the decomposed representation of a dataclass, breaking it down into individual
@@ -80,6 +81,9 @@ class ShatteredDataclass:
 	list_keyword_field__field4init: list[ast.keyword] = dataclasses.field(default_factory=list[ast.keyword])
 	"""Keyword arguments for dataclass initialization using field=field format."""
 
+	listIdentifiersStaticScalars: list[str] = dataclasses.field(default_factory=list[str])
+	"""Identifiers of unchanging scalar fields with `init=False`; mutually exclusive with `list_keyword_field__field4init`."""
+
 	listAnnotations: list[ast.expr] = dataclasses.field(default_factory=list[ast.expr])
 	"""Type annotations for each dataclass field in declaration order."""
 
@@ -99,7 +103,7 @@ class ShatteredDataclass:
 	"""Tuple-based return type annotation for functions returning decomposed field values."""
 
 @dataclasses.dataclass
-class DeReConstructField2ast:
+class DeReConstructField2ast: # slots?
 	"""
 	Transform a dataclass field into AST node representations for code generation.
 
@@ -217,7 +221,7 @@ 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 = cast('ast.Name', raiseIfNone(NodeTourist(
+		self.astAnnotation = cast(ast.Name, raiseIfNone(NodeTourist(
 			findThis = Be.AnnAssign.targetIs(IfThis.isNameIdentifier(self.name))
 			, doThat = Then.extractIt(DOT.annotation)
 			).captureLastMatch(dataclassClassDef)))
@@ -234,6 +238,8 @@ class DeReConstructField2ast:
 			dtype_asnameName: ast.Name = self.astAnnotation
 			if dtype_asnameName.id == 'Array3DLeavesTotal':
 				axesSubscript = Make.Subscript(Make.Name('tuple'), Make.Tuple([Make.Name('uint8'), Make.Name('uint8'), Make.Name('uint8')]))
+			if dtype_asnameName.id == 'Array2DLeavesTotal':
+				axesSubscript = Make.Subscript(Make.Name('tuple'), Make.Tuple([Make.Name('uint8'), Make.Name('uint8')]))
 			ast_expr = Make.Subscript(Make.Name(annotationType), Make.Tuple([axesSubscript, Make.Subscript(Make.Name('dtype'), dtype_asnameName)]))
 			constructor = 'array'
 			self.ledger.addImportFrom_asStr(moduleWithLogicalPath, constructor)
@@ -246,10 +252,35 @@ class DeReConstructField2ast:
 			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, Make.Call(self.astAnnotation, [Make.Constant(-1)]))
 			self.Z0Z_hack = (self.astAnnAssignConstructor, 'scalar')
 		elif isinstance(self.astAnnotation, ast.Subscript):
-			elementConstructor: str = self.metadata['elementConstructor']
-			self.ledger.addImportFrom_asStr(dataclassesDOTdataclassLogicalPathModule, elementConstructor)
+			elementConstructor: str = self.metadata.get('elementConstructor', 'generic')
+			if elementConstructor != 'generic':
+				self.ledger.addImportFrom_asStr(dataclassesDOTdataclassLogicalPathModule, elementConstructor)
 			takeTheTuple = deepcopy(self.astAnnotation.slice)
 			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, takeTheTuple)
 			self.Z0Z_hack = (self.astAnnAssignConstructor, elementConstructor)
 		if isinstance(self.astAnnotation, ast.Name):
 			self.ledger.addImportFrom_asStr(dataclassesDOTdataclassLogicalPathModule, self.astAnnotation.id)
+
+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

mapFolding/someAssemblyRequired/infoBooth.py

@@ -11,39 +11,57 @@ on empirical measurements and theoretical analysis of map folding algorithms for
 specific dimensional configurations.
 """
 
+from copy import deepcopy
 from hunterMakesPy import identifierDotAttribute
-from typing import Final
+from typing import Final, TypedDict
 
 dictionaryEstimatesMapFolding: Final[dict[tuple[int, ...], int]] = {
 	(2,2,2,2,2,2,2,2): 798148657152000,
 	(2,21): 776374224866624,
 	(3,15): 824761667826225,
 	(3,3,3,3): 85109616000000000000000000000000,
-	(8,8): 791274195985524900,
+	(8,8): 791274195985524900, # A test estimated 300,000 hours to compute.
 }
 """Estimates of multidimensional map folding `foldsTotal`."""
 
-identifierCallableSourceDEFAULT: Final[str] = 'count'
-"""Default identifier for the core counting function in algorithms."""
+class Default(TypedDict):
+	"""Default identifiers."""
 
-identifierCallableSourceDispatcherDEFAULT: Final[str] = 'doTheNeedful'
-"""Default identifier for dispatcher functions that route computational tasks."""
+	function: dict[str, str]
+	logicalPath: dict[str, identifierDotAttribute]
+	module: dict[str, str]
+	variable: dict[str, str]
 
-identifierCountingDEFAULT: Final[str] = 'groupsOfFolds'
-"""Default identifier for the primary counting variable in map folding computations."""
-
-identifierDataclassInstanceDEFAULT: Final[str] = 'state'
-"""Default variable name for dataclass instances in generated code."""
-
-identifierModuleDataPackingDEFAULT: Final[str] = 'dataPacking'
-"""Default identifier for modules containing data packing and unpacking functions."""
-
-identifierModuleSourceAlgorithmDEFAULT: Final[str] = 'daoOfMapFolding'
-"""Default identifier for the algorithm source module containing the base implementation."""
-
-logicalPathInfixAlgorithmDEFAULT: Final[identifierDotAttribute] = 'algorithms'
-"""Default logical path component for handmade algorithms."""
-
-logicalPathInfixDEFAULT: Final[identifierDotAttribute] = 'syntheticModules'
-"""Default logical path component for organizing synthetic generated modules."""
+default = Default(
+	function = {
+		'counting': 'count',
+		'dispatcher': 'doTheNeedful',
+		'initializeState': 'transitionOnGroupsOfFolds',
+	},
+	logicalPath = {
+		'algorithm': 'algorithms',
+		'synthetic': 'syntheticModules',
+	},
+	module = {
+		'algorithm': 'daoOfMapFolding',
+		'dataBasket': 'dataBaskets',
+		'initializeState': 'initializeState',
+	},
+	variable = {
+		'counting': 'groupsOfFolds',
+		'stateDataclass': 'MapFoldingState',
+		'stateInstance': 'state',
+	},
+)
 
+defaultA007822: Default = deepcopy(default)
+defaultA007822['function']['_processCompletedFutures'] = '_processCompletedFutures'
+defaultA007822['function']['filterAsymmetricFolds'] = 'filterAsymmetricFolds'
+defaultA007822['function']['getSymmetricFoldsTotal'] = 'getSymmetricFoldsTotal'
+defaultA007822['function']['initializeConcurrencyManager'] = 'initializeConcurrencyManager'
+defaultA007822['logicalPath']['assembly'] = 'someAssemblyRequired.A007822'
+defaultA007822['logicalPath']['synthetic'] += '.A007822'
+defaultA007822['module']['algorithm'] = 'algorithm'
+defaultA007822['module']['asynchronous'] = 'asynchronous'
+defaultA007822['variable']['counting'] = 'symmetricFolds'
+defaultA007822['variable']['stateDataclass'] = 'SymmetricFoldsState'

mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py

@@ -1,70 +1,81 @@
 """
 Map folding AST transformation system: Specialized job generation and optimization implementation.
 
-This module implements the specialized job generation layer of the map folding AST transformation
-system, executing the complete transformation process to convert generic map folding algorithms
-into highly optimized, standalone computation modules. Building upon the configuration orchestration
-established in the recipe system, this module applies the full sequence of transformations from
-pattern recognition through Numba compilation to produce self-contained computational solutions
-optimized for specific map dimensions and calculation contexts.
-
-The transformation implementation addresses the computational demands of map folding research where
-calculations can require hours or days to complete. The specialization process converts abstract
-algorithms with flexible parameters into concrete, statically-optimized code that leverages
-just-in-time compilation for maximum performance. Each generated module targets specific map
-shapes and calculation modes, enabling aggressive compiler optimizations based on known constraints
-and embedded constants.
-
-The optimization process executes systematic transformations including static value embedding to
-replace parameterized values with compile-time constants, dead code elimination to remove unused
-variables and code paths, parameter internalization to convert function parameters into embedded
-variables, import optimization to replace generic imports with specific implementations, Numba
-decoration with appropriate compilation directives, progress integration for long-running calculations,
-and launcher generation for standalone execution entry points.
-
-The resulting modules represent the culmination of the entire AST transformation system, producing
-self-contained Python scripts that execute independently with dramatically improved performance
-compared to original generic algorithms while maintaining mathematical correctness and providing
-essential progress feedback capabilities for large-scale computational research.
+Each generated module targets a specific map shape and calculation mode.
+
+The optimization process executes systematic transformations including static value embedding, dead code elimination, parameter
+internalization to convert function parameters into embedded variables, Numba decoration with appropriate compilation directives,
+progress integration for long-running calculations, and launcher generation for standalone execution entry points.
 """
 
-from astToolkit import (
-	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, packageSettings
-from mapFolding.dataBaskets import MapFoldingState
-from mapFolding.someAssemblyRequired import IfThis
-from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
+from astToolkit import Be, Make, NodeChanger, NodeTourist, parseLogicalPath2astModule, Then
+from astToolkit.containers import astModuleToIngredientsFunction, IngredientsFunction, IngredientsModule
+from hunterMakesPy import autoDecodingRLE, identifierDotAttribute
+from mapFolding import (
+	DatatypeLeavesTotal, dictionaryOEIS, getFoldsTotalKnown, getPathFilenameFoldsTotal, packageSettings)
+from mapFolding.dataBaskets import MapFoldingState, SymmetricFoldsState
+from mapFolding.someAssemblyRequired import DatatypeConfiguration, defaultA007822, dictionaryEstimatesMapFolding, IfThis
+from mapFolding.someAssemblyRequired.RecipeJob import customizeDatatypeViaImport, RecipeJobTheorem2
 from mapFolding.someAssemblyRequired.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight, SpicesJobNumba
-from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds
+from mapFolding.someAssemblyRequired.transformationTools import shatter_dataclassesDOTdataclass
 from pathlib import PurePosixPath
-from typing import cast, NamedTuple, TYPE_CHECKING
-from typing_extensions import TypeIs
+from typing import cast
 import ast
 
-if TYPE_CHECKING:
-	from collections.abc import Callable
-
-listIdentifiersStaticValuesHARDCODED: list[str] = ['dimensionsTotal', 'leavesTotal']
-
-def addLauncherNumbaProgress(ingredientsModule: IngredientsModule, ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2, spices: SpicesJobNumba) -> tuple[IngredientsModule, IngredientsFunction]:
-	"""Add progress tracking capabilities to a Numba-optimized function.
+# TODO More convergence with `makeJobTheorem2codon`
+
+# TODO Dynamically calculate the bitwidth of each datatype. NOTE I've delayed dynamic calculation because I don't know how to
+# calculate what 'elephino' needs. But perhaps I can dynamically calculate 'leavesTotal' and 'foldsTotal' and hardcode 'elephino.'
+# That would probably be an improvement.
+listDatatypeConfigurations: list[DatatypeConfiguration] = [
+	DatatypeConfiguration(datatypeIdentifier='DatatypeLeavesTotal', typeModule='numba', typeIdentifier='uint8', type_asname='DatatypeLeavesTotal'),
+	DatatypeConfiguration(datatypeIdentifier='DatatypeElephino', typeModule='numba', typeIdentifier='uint16', type_asname='DatatypeElephino'),
+	DatatypeConfiguration(datatypeIdentifier='DatatypeFoldsTotal', typeModule='numba', typeIdentifier='uint64', type_asname='DatatypeFoldsTotal'),
+	DatatypeConfiguration(datatypeIdentifier='Array1DLeavesTotal', typeModule='numpy', typeIdentifier='uint8', type_asname='Array1DLeavesTotal'),
+	DatatypeConfiguration(datatypeIdentifier='Array1DElephino', typeModule='numpy', typeIdentifier='uint16', type_asname='Array1DElephino'),
+	DatatypeConfiguration(datatypeIdentifier='Array3DLeavesTotal', typeModule='numpy', typeIdentifier='uint8', type_asname='Array3DLeavesTotal'),
+]
+
+def addLauncher(ingredientsModule: IngredientsModule, ingredientsCount: IngredientsFunction, job: RecipeJobTheorem2) -> tuple[IngredientsModule, IngredientsFunction]:
+	"""Add a standalone launcher section to a computation module."""
+	linesLaunch: str = f"""
+if __name__ == '__main__':
+	import time
+	timeStart = time.perf_counter()
+	foldsTotal = int({job.identifierCallable}() * {job.state.leavesTotal})
+	print(time.perf_counter() - timeStart)
+	print('\\nmap {job.state.mapShape} =', foldsTotal)
+	writeStream = open('{job.pathFilenameFoldsTotal.as_posix()}', 'w')
+	writeStream.write(str(foldsTotal))
+	writeStream.close()
+"""
+	ingredientsModule.appendLauncher(ast.parse(linesLaunch))
+	NodeChanger(Be.Return, Then.replaceWith(Make.Return(job.shatteredDataclass.countingVariableName))).visit(ingredientsCount.astFunctionDef)
+	ingredientsCount.astFunctionDef.returns = job.shatteredDataclass.countingVariableAnnotation
 
-	(AI generated docstring)
+	return ingredientsModule, ingredientsCount
 
-	This function modifies both the module and the function to integrate Numba-compatible
-	progress tracking for long-running calculations. It performs several key transformations:
+def addLauncherA007822(ingredientsModule: IngredientsModule, ingredientsCount: IngredientsFunction, job: RecipeJobTheorem2) -> tuple[IngredientsModule, IngredientsFunction]:
+	"""Add a standalone launcher section to a computation module."""
+	linesLaunch: str = f"""
+if __name__ == '__main__':
+	import time
+	timeStart = time.perf_counter()
+	foldsTotal = int({job.identifierCallable}())
+	print(time.perf_counter() - timeStart)
+	print('\\nmap {job.state.mapShape} =', foldsTotal)
+	writeStream = open('{job.pathFilenameFoldsTotal.as_posix()}', 'w')
+	writeStream.write(str(foldsTotal))
+	writeStream.close()
+"""
+	ingredientsModule.appendLauncher(ast.parse(linesLaunch))
+	NodeChanger(Be.Return, Then.replaceWith(Make.Return(job.shatteredDataclass.countingVariableName))).visit(ingredientsCount.astFunctionDef)
+	ingredientsCount.astFunctionDef.returns = job.shatteredDataclass.countingVariableAnnotation
 
-	1. Adds a progress bar parameter to the function signature
-	2. Replaces counting increments with progress bar updates
-	3. Creates a launcher section that displays and updates progress
-	4. Configures file output to save results upon completion
+	return ingredientsModule, ingredientsCount
 
-	The progress tracking is particularly important for map folding calculations
-	which can take hours or days to complete, providing visual feedback and
-	estimated completion times.
+def addLauncherNumbaProgress(ingredientsModule: IngredientsModule, ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2, spices: SpicesJobNumba) -> tuple[IngredientsModule, IngredientsFunction]:
+	"""Add a tqdm progress bar to a Numba-optimized function.
 
 	Parameters
 	----------
@@ -81,12 +92,13 @@ def addLauncherNumbaProgress(ingredientsModule: IngredientsModule, ingredientsFu
 	-------
 	moduleAndFunction : tuple[IngredientsModule, IngredientsFunction]
 		Modified module and function with integrated progress tracking capabilities.
-
 	"""
+# TODO When using the progress bar, `count` does not return `groupsOfFolds`, so `count` does not `*= 2`. So, I have to manually
+# change the update value. This should be dynamic.
 	linesLaunch: str = f"""
 if __name__ == '__main__':
-	with ProgressBar(total={job.foldsTotalEstimated}, update_interval=2) as statusUpdate:
-		{job.countCallable}(statusUpdate)
+	with ProgressBar(total={job.foldsTotalEstimated//job.state.leavesTotal}, update_interval=2) as statusUpdate:
+		{job.identifierCallable}(statusUpdate)
 		foldsTotal = statusUpdate.n * {job.state.leavesTotal}
 		print('\\nmap {job.state.mapShape} =', foldsTotal)
 		writeStream = open('{job.pathFilenameFoldsTotal.as_posix()}', 'w')
@@ -98,17 +110,16 @@ if __name__ == '__main__':
 	ingredientsModule.imports.addImportFrom_asStr('numba_progress', numba_progressPythonClass)
 	ingredientsModule.imports.addImportFrom_asStr('numba_progress', numba_progressNumbaType)
 
-	ast_argNumbaProgress = ast.arg(arg=spices.numbaProgressBarIdentifier, annotation=ast.Name(id=numba_progressPythonClass, ctx=ast.Load()))
+	ast_argNumbaProgress = Make.arg(spices.numbaProgressBarIdentifier, annotation=Make.Name(numba_progressPythonClass))
 	ingredientsFunction.astFunctionDef.args.args.append(ast_argNumbaProgress)
 
-	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)
+	NodeChanger(
+		findThis = Be.AugAssign.targetIs(IfThis.isNameIdentifier(job.shatteredDataclass.countingVariableName.id))
+		, doThat = Then.replaceWith(Make.Expr(Make.Call(Make.Attribute(Make.Name(spices.numbaProgressBarIdentifier),'update'),[Make.Constant(2)])))
+	).visit(ingredientsFunction.astFunctionDef)
 
-	removeReturnStatement = NodeChanger(Be.Return, Then.removeIt)
-	removeReturnStatement.visit(ingredientsFunction.astFunctionDef)
-	ingredientsFunction.astFunctionDef.returns = Make.Constant(value=None)
+	NodeChanger(Be.Return, Then.removeIt).visit(ingredientsFunction.astFunctionDef)
+	ingredientsFunction.astFunctionDef.returns = Make.Constant(None)
 
 	ingredientsModule.appendLauncher(ast.parse(linesLaunch))
 
@@ -143,7 +154,6 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 	-------
 	modifiedFunction : IngredientsFunction
 		The modified function with parameters converted to initialized variables.
-
 	"""
 	ingredientsFunction.imports.update(job.shatteredDataclass.imports)
 
@@ -162,25 +172,23 @@ 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(eval(f"job.state.{ast_arg.arg}"))  # noqa: S307
+						cast(ast.Constant, cast(ast.Call, ImaAnnAssign.value).args[0]).value = int(eval(f"job.state.{ast_arg.arg}"))  # noqa: S307
 					case 'array':
 						dataAsStrRLE: str = autoDecodingRLE(eval(f"job.state.{ast_arg.arg}"), assumeAddSpaces=True)  # noqa: S307
-						dataAs_astExpr: ast.expr = cast('ast.Expr', ast.parse(dataAsStrRLE).body[0]).value
-						cast('ast.Call', ImaAnnAssign.value).args = [dataAs_astExpr]
+						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: 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)
+			NodeChanger(IfThis.is_argIdentifier(ast_arg.arg), Then.removeIt).visit(ingredientsFunction.astFunctionDef)
 
 	ast.fix_missing_locations(ingredientsFunction.astFunctionDef)
 	return ingredientsFunction
@@ -215,95 +223,35 @@ def makeJobNumba(job: RecipeJobTheorem2, spices: SpicesJobNumba) -> None:
 		Optimization settings including Numba parameters and progress options.
 
 	"""
-	astFunctionDef: ast.FunctionDef = raiseIfNone(extractFunctionDef(job.source_astModule, job.countCallable))
-	ingredientsCount: IngredientsFunction = IngredientsFunction(astFunctionDef, LedgerOfImports())
+	# ingredientsCount: IngredientsFunction = IngredientsFunction(raiseIfNone(extractFunctionDef(job.source_astModule, job.identifierCallableSource)))  # noqa: ERA001
+	ingredientsCount: IngredientsFunction = astModuleToIngredientsFunction(job.source_astModule, job.identifierCallableSource)
 
-	listIdentifiersStaticValues: list[str] = listIdentifiersStaticValuesHARDCODED
-	for identifier in listIdentifiersStaticValues:
-		findThis: Callable[[ast.AST], TypeIs[ast.Name] | bool] = IfThis.isNameIdentifier(identifier)
-		doThat: Callable[[ast.Name], ast.Constant] = Then.replaceWith(Make.Constant(int(eval(f"job.state.{identifier}"))))  # noqa: S307
-		NodeChanger(findThis, doThat).visit(ingredientsCount.astFunctionDef)
+	for identifier in job.shatteredDataclass.listIdentifiersStaticScalars:
+		NodeChanger(IfThis.isNameIdentifier(identifier)
+			, Then.replaceWith(Make.Constant(int(eval(f"job.state.{identifier}"))))  # noqa: S307
+		).visit(ingredientsCount.astFunctionDef)
 
 	ingredientsModule = IngredientsModule()
-	# This launcher eliminates the use of one identifier, so run it now and you can dynamically determine which variables are not used
+# TODO Refactor the subtly complicated interactions of these launchers with `move_arg2FunctionDefDOTbodyAndAssignInitialValues`
+# Consider `astToolkit.transformationTools.removeUnusedParameters`.
+# Generalize some parts of the launchers, especially writing to disk. Writing to disk is NOT robust enough. It doesn't even try to make a directory.
 	if spices.useNumbaProgressBar:
 		ingredientsModule, ingredientsCount = addLauncherNumbaProgress(ingredientsModule, ingredientsCount, job, spices)
 		spices.parametersNumba['nogil'] = True
 	else:
-		linesLaunch: str = f"""
-if __name__ == '__main__':
-	import time
-	timeStart = time.perf_counter()
-	foldsTotal = int({job.countCallable}() * {job.state.leavesTotal})
-	print(time.perf_counter() - timeStart)
-	print('\\nmap {job.state.mapShape} =', foldsTotal)
-	writeStream = open('{job.pathFilenameFoldsTotal.as_posix()}', 'w')
-	writeStream.write(str(foldsTotal))
-	writeStream.close()
-"""
-	# 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)
-		ingredientsCount.astFunctionDef.returns = job.shatteredDataclass.countingVariableAnnotation
+		ingredientsModule, ingredientsCount = addLauncher(ingredientsModule, ingredientsCount, job)  # noqa: ERA001
+		# ingredientsModule, ingredientsCount = addLauncherA007822(ingredientsModule, ingredientsCount, job)
 
 	ingredientsCount = move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsCount, job)
-	class DatatypeConfig(NamedTuple):
-		"""Configuration for mapping framework datatypes to Numba-compatible types.
-
-		This configuration class defines how abstract datatypes used in the map folding
-		framework should be replaced with concrete Numba-compatible types during code
-		generation. Each configuration specifies the source module, target type name,
-		and optional import alias for the transformation.
-
-		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
-		Z0Z_asname: str | None = None
-
-	listDatatypeConfigs: list[DatatypeConfig] = [
-		DatatypeConfig(fml='DatatypeLeavesTotal', Z0Z_module='numba', Z0Z_type_name='uint8'),
-		DatatypeConfig(fml='DatatypeElephino', Z0Z_module='numba', Z0Z_type_name='uint16'),
-		DatatypeConfig(fml='DatatypeFoldsTotal', Z0Z_module='numba', Z0Z_type_name='uint64'),
-	]
-
-	for datatypeConfig in listDatatypeConfigs:
-		ingredientsModule.imports.addImportFrom_asStr(datatypeConfig.Z0Z_module, datatypeConfig.Z0Z_type_name)
-		statement = Make.Assign(
-			[Make.Name(datatypeConfig.fml, ast.Store())],
-			Make.Name(datatypeConfig.Z0Z_type_name)
-		)
-		ingredientsModule.appendPrologue(statement=statement)
-
-	ingredientsCount.imports.removeImportFromModule('mapFolding.dataBaskets')
 
-	listNumPyTypeConfigs = [
-		DatatypeConfig(fml='Array1DLeavesTotal', Z0Z_module='numpy', Z0Z_type_name='uint8', Z0Z_asname='Array1DLeavesTotal'),
-		DatatypeConfig(fml='Array1DElephino', Z0Z_module='numpy', Z0Z_type_name='uint16', Z0Z_asname='Array1DElephino'),
-		DatatypeConfig(fml='Array3DLeavesTotal', Z0Z_module='numpy', Z0Z_type_name='uint8', Z0Z_asname='Array3DLeavesTotal'),
-	]
+	ingredientsCount, ingredientsModule = customizeDatatypeViaImport(ingredientsCount, ingredientsModule, listDatatypeConfigurations)
 
-	for typeConfig in listNumPyTypeConfigs:
-		ingredientsCount.imports.removeImportFrom(typeConfig.Z0Z_module, None, typeConfig.fml)
-		ingredientsCount.imports.addImportFrom_asStr(typeConfig.Z0Z_module, typeConfig.Z0Z_type_name, typeConfig.Z0Z_asname)
+	ingredientsCount.imports.removeImportFromModule('mapFolding.dataBaskets')
 
 	ingredientsCount.astFunctionDef.decorator_list = [] # TODO low-priority, handle this more elegantly
 	ingredientsCount = decorateCallableWithNumba(ingredientsCount, spices.parametersNumba)
 	ingredientsModule.appendIngredientsFunction(ingredientsCount)
-	write_astModule(ingredientsModule, job.pathFilenameModule, job.packageIdentifier)
+	ingredientsModule.write_astModule(job.pathFilenameModule, identifierPackage=job.packageIdentifier or '')
 
 	"""
 	Overview
@@ -312,26 +260,54 @@ if __name__ == '__main__':
 		- `makeJobNumba` increases optimization especially by limiting its capabilities to just one set of parameters
 	- the synthesized module must run well as a standalone interpreted-Python script
 	- the next major optimization step will (probably) be to use the module synthesized by `makeJobNumba` to compile a standalone executable
-	- Nevertheless, at each major optimization step, the code is constantly being improved and optimized, so everything must be well organized (read: semantic) and able to handle a range of arbitrary upstream and not disrupt downstream transformations
-
-	Necessary
-	- Move the function's parameters to the function body,
-	- initialize identifiers with their state types and values,
-
-	Optimizations
-	- replace static-valued identifiers with their values
-	- narrowly focused imports
-
-	Minutia
-	- do not use `with` statement inside numba jitted code, except to use numba's obj mode
+	- Nevertheless, at each major optimization step, the code is constantly being improved and optimized, so everything must be
+		well organized (read: semantic) and able to handle a range of arbitrary upstream and not disrupt downstream transformations
 	"""
 
-if __name__ == '__main__':
-	state = transitionOnGroupsOfFolds(MapFoldingState((2,5)))
+def fromMapShape(mapShape: tuple[DatatypeLeavesTotal, ...]) -> None:
+	"""Generate and write an optimized Numba-compiled map folding module for a specific map shape."""
+	from mapFolding.syntheticModules.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
+	state: MapFoldingState = transitionOnGroupsOfFolds(MapFoldingState(mapShape))
+	foldsTotalEstimated: int = getFoldsTotalKnown(state.mapShape) or dictionaryEstimatesMapFolding.get(state.mapShape, 0)
 	pathModule = PurePosixPath(packageSettings.pathPackage, 'jobs')
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
-	aJob = RecipeJobTheorem2(state, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
+	aJob = RecipeJobTheorem2(state, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal, foldsTotalEstimated=foldsTotalEstimated)
 	spices = SpicesJobNumba(useNumbaProgressBar=True, parametersNumba=parametersNumbaLight)
 	makeJobNumba(aJob, spices)
 
-# TODO Improve this module with lessons learned in `makeJobTheorem2codon`.
+def A007822(n: int) -> None:
+	"""Generate and write an optimized Numba-compiled map folding module for a specific map shape."""
+	from mapFolding.syntheticModules.A007822.initializeState import transitionOnGroupsOfFolds  # noqa: PLC0415
+	state = transitionOnGroupsOfFolds(SymmetricFoldsState((1, 2 * n)))
+	foldsTotalEstimated: int = dictionaryOEIS['A007822']['valuesKnown'].get(n, 0)
+	shatteredDataclass = shatter_dataclassesDOTdataclass(f"{packageSettings.identifierPackage}.{defaultA007822['module']['dataBasket']}"
+		, defaultA007822['variable']['stateDataclass'], defaultA007822['variable']['stateInstance'])
+	source_astModule: ast.Module = parseLogicalPath2astModule(f'{packageSettings.identifierPackage}.{defaultA007822['logicalPath']['synthetic']}.theorem2Numba')
+	identifierCallableSource: str = defaultA007822['function']['counting']
+	sourceLogicalPathModuleDataclass: identifierDotAttribute = f'{packageSettings.identifierPackage}.dataBaskets'
+	sourceDataclassIdentifier: str = defaultA007822['variable']['stateDataclass']
+	sourceDataclassInstance: str = defaultA007822['variable']['stateInstance']
+	sourcePathPackage: PurePosixPath | None = PurePosixPath(packageSettings.pathPackage)
+	sourcePackageIdentifier: str | None = packageSettings.identifierPackage
+	pathPackage: PurePosixPath | None = None
+	pathModule = PurePosixPath(packageSettings.pathPackage, 'jobs')
+	fileExtension: str = packageSettings.fileExtension
+	pathFilenameFoldsTotal = pathModule / ('A007822_' + str(n))
+	packageIdentifier: str | None = None
+	logicalPathRoot: identifierDotAttribute | None = None
+	moduleIdentifier: str = pathFilenameFoldsTotal.stem
+	identifierCallable: str = identifierCallableSource
+	identifierDataclass: str | None = sourceDataclassIdentifier
+	identifierDataclassInstance: str | None = sourceDataclassInstance
+	logicalPathModuleDataclass: identifierDotAttribute | None = sourceLogicalPathModuleDataclass
+	aJob = RecipeJobTheorem2(state, foldsTotalEstimated, shatteredDataclass, source_astModule, identifierCallableSource, sourceLogicalPathModuleDataclass
+		, sourceDataclassIdentifier, sourceDataclassInstance, sourcePathPackage, sourcePackageIdentifier, pathPackage, pathModule, fileExtension
+		, pathFilenameFoldsTotal, packageIdentifier, logicalPathRoot, moduleIdentifier, identifierCallable, identifierDataclass, identifierDataclassInstance
+		, logicalPathModuleDataclass)
+	spices = SpicesJobNumba(useNumbaProgressBar=False, parametersNumba=parametersNumbaLight)
+	makeJobNumba(aJob, spices)
+
+if __name__ == '__main__':
+	mapShape: tuple[DatatypeLeavesTotal, ...] = (2,21)  # noqa: ERA001
+	fromMapShape(mapShape)  # noqa: ERA001
+	# A007822(8)