mapFolding 0.16.4__py3-none-any.whl → 0.17.1__py3-none-any.whl

mapFolding/someAssemblyRequired/RecipeJob.py

@@ -1,16 +1,16 @@
 """Configuration by dataclass."""
 
-from astToolkit import identifierDotAttribute, IngredientsFunction, IngredientsModule, parseLogicalPath2astModule
+from astToolkit import identifierDotAttribute, parseLogicalPath2astModule
+from astToolkit.containers import IngredientsFunction, IngredientsModule, LedgerOfImports
 from astToolkit.transformationTools import pythonCode2ast_expr
 from hunterMakesPy import autoDecodingRLE
-# TODO 'The...' identifiers are a vestigial semiotic system. Do I still need to import `asname`? If so, would different
+# TODO 'The____' identifiers are a vestigial semiotic system. Do I still need to import `asname`? If so, would different
 # identifiers better integrate into the current semiotics?
 from mapFolding import (
 	DatatypeElephino as TheDatatypeElephino, DatatypeFoldsTotal as TheDatatypeFoldsTotal,
 	DatatypeLeavesTotal as TheDatatypeLeavesTotal, getPathFilenameFoldsTotal, getPathRootJobDEFAULT, packageSettings)
-from mapFolding.dataBaskets import MapFoldingState
-from mapFolding.someAssemblyRequired import DatatypeConfiguration, default
-from mapFolding.someAssemblyRequired._toolkitContainers import ShatteredDataclass
+from mapFolding.dataBaskets import MapFoldingState, SymmetricFoldsState
+from mapFolding.someAssemblyRequired import DatatypeConfiguration, default, ShatteredDataclass
 from mapFolding.someAssemblyRequired.transformationTools import shatter_dataclassesDOTdataclass
 from pathlib import Path, PurePosixPath
 from typing import cast
@@ -22,18 +22,8 @@ class RecipeJobTheorem2:
 	"""Configuration recipe for generating map folding computation jobs.
 
 	This dataclass serves as the central configuration hub for the code transformation
-	assembly line that converts generic map folding algorithms into highly optimized,
-	specialized computation modules. The recipe encapsulates all parameters required
-	for source code analysis, target file generation, datatype mapping, and compilation
-	optimization settings.
-
-	The transformation process operates by extracting functions from source modules,
-	embedding concrete parameter values, eliminating dead code paths, and generating
-	standalone Python modules optimized for specific map dimensions.
-
-	The recipe maintains both source configuration (where to find the generic algorithm)
-	and target configuration (where to write the optimized module), along with the
-	computational state that provides concrete values for the transformation process.
+	assembly line that converts generic map folding algorithms into optimized,
+	specialized modules.
 
 	Attributes
 	----------
@@ -87,7 +77,7 @@ class RecipeJobTheorem2:
 		Type alias for leaf count datatype.
 	"""
 
-	state: MapFoldingState
+	state: MapFoldingState | SymmetricFoldsState
 	"""The map folding computation state containing dimensions and initial values."""
 	foldsTotalEstimated: int = 0
 	"""Estimated total number of folds for progress tracking."""
@@ -129,7 +119,7 @@ class RecipeJobTheorem2:
 	"""Logical path root; probably corresponds to physical filesystem directory."""
 	moduleIdentifier: str = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
 	"""Target module identifier."""
-	countCallable: str = identifierCallableSource
+	identifierCallable: str = identifierCallableSource
 	"""Name of the counting function in generated module."""
 	identifierDataclass: str | None = sourceDataclassIdentifier
 	"""Target dataclass identifier."""
@@ -211,12 +201,12 @@ class RecipeJobTheorem2:
 		"""
 		pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(self.state.mapShape))
 
-		if self.moduleIdentifier is None: # pyright: ignore[reportUnnecessaryComparison]
-			self.moduleIdentifier = pathFilenameFoldsTotal.stem
-
 		if self.pathFilenameFoldsTotal is None: # pyright: ignore[reportUnnecessaryComparison]
 			self.pathFilenameFoldsTotal = pathFilenameFoldsTotal
 
+		if self.moduleIdentifier is None: # pyright: ignore[reportUnnecessaryComparison]
+			self.moduleIdentifier = self.pathFilenameFoldsTotal.stem
+
 		if self.shatteredDataclass is None and self.logicalPathModuleDataclass and self.identifierDataclass and self.identifierDataclassInstance: # pyright: ignore[reportUnnecessaryComparison]
 			self.shatteredDataclass = shatter_dataclassesDOTdataclass(self.logicalPathModuleDataclass, self.identifierDataclass, self.identifierDataclassInstance)
 
@@ -245,11 +235,11 @@ def moveShatteredDataclass_arg2body(identifier: str, job: RecipeJobTheorem2) ->
 	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(eval(f"job.state.{identifier}"))  # noqa: S307
+			cast(ast.Constant, cast(ast.Call, Ima___Assign.value).args[0]).value = int(eval(f"job.state.{identifier}"))  # noqa: S307
 		case 'array':
 			dataAsStrRLE: str = autoDecodingRLE(eval(f"job.state.{identifier}"), assumeAddSpaces=True)  # noqa: S307
 			dataAs_ast_expr: ast.expr = pythonCode2ast_expr(dataAsStrRLE)
-			cast('ast.Call', Ima___Assign.value).args = [dataAs_ast_expr]
+			cast(ast.Call, Ima___Assign.value).args = [dataAs_ast_expr]
 		case _:
 			pass
 	return Ima___Assign

mapFolding/someAssemblyRequired/__init__.py

@@ -74,6 +74,7 @@ calculations through the strategic application of compiler optimization techniqu
 
 from mapFolding.someAssemblyRequired.infoBooth import (
     default as default,
+    Default as Default,
     defaultA007822 as defaultA007822,
 	dictionaryEstimatesMapFolding as dictionaryEstimatesMapFolding,
 )

mapFolding/someAssemblyRequired/_toolkitContainers.py

@@ -25,7 +25,8 @@ 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
@@ -220,7 +221,7 @@ class DeReConstructField2ast: # slots?
 		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)))
@@ -251,8 +252,9 @@ class DeReConstructField2ast: # slots?
 			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)

mapFolding/someAssemblyRequired/infoBooth.py

@@ -44,6 +44,7 @@ default = Default(
 	},
 	module = {
 		'algorithm': 'daoOfMapFolding',
+		'dataBasket': 'dataBaskets',
 		'initializeState': 'initializeState',
 	},
 	variable = {
@@ -62,5 +63,5 @@ defaultA007822['logicalPath']['assembly'] = 'someAssemblyRequired.A007822'
 defaultA007822['logicalPath']['synthetic'] += '.A007822'
 defaultA007822['module']['algorithm'] = 'algorithm'
 defaultA007822['module']['asynchronous'] = 'asynchronous'
-# defaultA007822['variable']['counting'] = 'symmetricFolds'
+defaultA007822['variable']['counting'] = 'symmetricFolds'
 defaultA007822['variable']['stateDataclass'] = 'SymmetricFoldsState'

mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py

@@ -8,16 +8,16 @@ internalization to convert function parameters into embedded variables, Numba de
 progress integration for long-running calculations, and launcher generation for standalone execution entry points.
 """
 
-from astToolkit import (
-	Be, extractFunctionDef, IngredientsFunction, IngredientsModule, Make, NodeChanger, NodeTourist, Then)
-from astToolkit.transformationTools import write_astModule
-from hunterMakesPy import autoDecodingRLE, raiseIfNone
-from mapFolding import DatatypeLeavesTotal, getFoldsTotalKnown, getPathFilenameFoldsTotal, packageSettings
-from mapFolding.dataBaskets import MapFoldingState
-from mapFolding.someAssemblyRequired import DatatypeConfiguration, dictionaryEstimatesMapFolding, IfThis
+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
 import ast
@@ -42,7 +42,26 @@ def addLauncher(ingredientsModule: IngredientsModule, ingredientsCount: Ingredie
 if __name__ == '__main__':
 	import time
 	timeStart = time.perf_counter()
-	foldsTotal = int({job.countCallable}() * {job.state.leavesTotal})
+	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
+
+	return ingredientsModule, ingredientsCount
+
+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')
@@ -79,7 +98,7 @@ def addLauncherNumbaProgress(ingredientsModule: IngredientsModule, ingredientsFu
 	linesLaunch: str = f"""
 if __name__ == '__main__':
 	with ProgressBar(total={job.foldsTotalEstimated//job.state.leavesTotal}, update_interval=2) as statusUpdate:
-		{job.countCallable}(statusUpdate)
+		{job.identifierCallable}(statusUpdate)
 		foldsTotal = statusUpdate.n * {job.state.leavesTotal}
 		print('\\nmap {job.state.mapShape} =', foldsTotal)
 		writeStream = open('{job.pathFilenameFoldsTotal.as_posix()}', 'w')
@@ -153,19 +172,19 @@ 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)
 
@@ -204,7 +223,8 @@ def makeJobNumba(job: RecipeJobTheorem2, spices: SpicesJobNumba) -> None:
 		Optimization settings including Numba parameters and progress options.
 
 	"""
-	ingredientsCount: IngredientsFunction = IngredientsFunction(raiseIfNone(extractFunctionDef(job.source_astModule, job.countCallable)))
+	# ingredientsCount: IngredientsFunction = IngredientsFunction(raiseIfNone(extractFunctionDef(job.source_astModule, job.identifierCallableSource)))  # noqa: ERA001
+	ingredientsCount: IngredientsFunction = astModuleToIngredientsFunction(job.source_astModule, job.identifierCallableSource)
 
 	for identifier in job.shatteredDataclass.listIdentifiersStaticScalars:
 		NodeChanger(IfThis.isNameIdentifier(identifier)
@@ -219,7 +239,8 @@ def makeJobNumba(job: RecipeJobTheorem2, spices: SpicesJobNumba) -> None:
 		ingredientsModule, ingredientsCount = addLauncherNumbaProgress(ingredientsModule, ingredientsCount, job, spices)
 		spices.parametersNumba['nogil'] = True
 	else:
-		ingredientsModule, ingredientsCount = addLauncher(ingredientsModule, ingredientsCount, job)
+		ingredientsModule, ingredientsCount = addLauncher(ingredientsModule, ingredientsCount, job)  # noqa: ERA001
+		# ingredientsModule, ingredientsCount = addLauncherA007822(ingredientsModule, ingredientsCount, job)
 
 	ingredientsCount = move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsCount, job)
 
@@ -230,7 +251,7 @@ def makeJobNumba(job: RecipeJobTheorem2, spices: SpicesJobNumba) -> None:
 	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
@@ -245,6 +266,7 @@ def makeJobNumba(job: RecipeJobTheorem2, spices: SpicesJobNumba) -> None:
 
 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')
@@ -253,6 +275,39 @@ def fromMapShape(mapShape: tuple[DatatypeLeavesTotal, ...]) -> None:
 	spices = SpicesJobNumba(useNumbaProgressBar=True, parametersNumba=parametersNumbaLight)
 	makeJobNumba(aJob, spices)
 
+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, ...] = (5,5)
-	fromMapShape(mapShape)
+	mapShape: tuple[DatatypeLeavesTotal, ...] = (2,21)  # noqa: ERA001
+	fromMapShape(mapShape)  # noqa: ERA001
+	# A007822(8)

mapFolding/someAssemblyRequired/makeJobTheorem2codon.py

@@ -2,10 +2,9 @@
 
 https://docs.exaloop.io/start/install/
 """
-
 from astToolkit import (
-	Be, extractFunctionDef, Grab, identifierDotAttribute, IngredientsFunction, IngredientsModule, Make, NodeChanger,
-	parseLogicalPath2astModule, Then)
+	Be, extractFunctionDef, Grab, identifierDotAttribute, Make, NodeChanger, parseLogicalPath2astModule, Then)
+from astToolkit.containers import IngredientsFunction, IngredientsModule
 from astToolkit.transformationTools import removeUnusedParameters, write_astModule
 from hunterMakesPy import raiseIfNone
 from mapFolding import DatatypeLeavesTotal, getPathFilenameFoldsTotal, packageSettings
@@ -106,8 +105,8 @@ def _variableCompatibility(ingredientsFunction: IngredientsFunction, job: Recipe
 								,  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)
+					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
@@ -124,7 +123,7 @@ def makeJob(job: RecipeJobTheorem2) -> None:
 		Configuration recipe containing source locations, target paths, raw materials, and state.
 
 	"""
-	ingredientsCount: IngredientsFunction = IngredientsFunction(raiseIfNone(extractFunctionDef(job.source_astModule, job.countCallable)))
+	ingredientsCount: IngredientsFunction = IngredientsFunction(raiseIfNone(extractFunctionDef(job.source_astModule, job.identifierCallable)))
 	ingredientsCount.astFunctionDef.decorator_list = []
 
 	# Replace identifiers-with-static-values with their values.
@@ -134,7 +133,7 @@ def makeJob(job: RecipeJobTheorem2) -> None:
 		).visit(ingredientsCount.astFunctionDef)
 
 	ingredientsCount.imports.update(job.shatteredDataclass.imports)
-	ingredientsCount = removeUnusedParameters(ingredientsCount)
+	ingredientsCount.removeUnusedParameters()
 	NodeChanger(Be.arg, lambda removeIt: ingredientsCount.astFunctionDef.body.insert(0, moveShatteredDataclass_arg2body(removeIt.arg, job))).visit(ingredientsCount.astFunctionDef)
 
 	ingredientsCount = _addWriteFoldsTotal(ingredientsCount, job)
@@ -142,7 +141,7 @@ def makeJob(job: RecipeJobTheorem2) -> None:
 
 	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)))])]))
+			, body=[Make.Expr(Make.Call(Make.Name(job.identifierCallable)))])]))
 
 	ingredientsCount, ingredientsModule = customizeDatatypeViaImport(ingredientsCount, ingredientsModule, listDatatypeConfigurations)
 
@@ -159,13 +158,13 @@ def makeJob(job: RecipeJobTheorem2) -> None:
 			'-']
 		streamText = subprocess.Popen(buildCommand, stdin=subprocess.PIPE, text=True)
 		if streamText.stdin is not None:
-			write_astModule(ingredientsModule, pathFilename=cast('TextIOBase', streamText.stdin), packageName=job.packageIdentifier)
+			write_astModule(ingredientsModule, pathFilename=cast(TextIOBase, streamText.stdin), packageName=job.packageIdentifier)
 			streamText.stdin.close()
 		streamText.wait()
 		subprocess.run(['/usr/bin/strip', str(job.pathFilenameModule.with_suffix(''))], check=False)
 		sys.stdout.write(f"sudo systemd-run --unit={job.moduleIdentifier} --nice=-10 --property=CPUAffinity=0 {job.pathFilenameModule.with_suffix('')}\n")
 	else:
-		write_astModule(ingredientsModule, pathFilename=job.pathFilenameModule, packageName=job.packageIdentifier)
+		ingredientsModule.write_astModule(job.pathFilenameModule, identifierPackage=job.packageIdentifier or '')
 		sys.stdout.write(f"python {Path(job.pathFilenameModule)}\n")
 
 def fromMapShape(mapShape: tuple[DatatypeLeavesTotal, ...]) -> None:

mapFolding/someAssemblyRequired/makingModules_count.py

@@ -3,13 +3,13 @@
 These transformation functions will work on at least two different algorithms. If a transformation function only works on a
 specific type of algorithm, it will be in a subdirectory.
 """
-from astToolkit import (
-	astModuleToIngredientsFunction, Be, DOT, Grab, identifierDotAttribute, IngredientsFunction, IngredientsModule,
-	LedgerOfImports, Make, NodeChanger, NodeTourist, Then)
-from astToolkit.transformationTools import inlineFunctionDef, removeUnusedParameters, write_astModule
+from astToolkit import Be, DOT, Grab, identifierDotAttribute, Make, NodeChanger, NodeTourist, Then
+from astToolkit.containers import (
+	astModuleToIngredientsFunction, IngredientsFunction, IngredientsModule, LedgerOfImports)
+from astToolkit.transformationTools import inlineFunctionDef
 from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
-from mapFolding.someAssemblyRequired import default, IfThis, ShatteredDataclass
+from mapFolding.someAssemblyRequired import default, Default, IfThis, ShatteredDataclass
 from mapFolding.someAssemblyRequired.toolkitMakeModules import findDataclass, getLogicalPath, getPathFilename
 from mapFolding.someAssemblyRequired.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight
 from mapFolding.someAssemblyRequired.transformationTools import (
@@ -48,7 +48,7 @@ def makeMapFoldingNumba(astModule: ast.Module, identifierModule: str, identifier
 
 	ingredientsFunction.imports.update(shatteredDataclass.imports)
 	ingredientsFunction: IngredientsFunction = removeDataclassFromFunction(ingredientsFunction, shatteredDataclass)
-	ingredientsFunction = removeUnusedParameters(ingredientsFunction)
+	ingredientsFunction.removeUnusedParameters()
 	ingredientsFunction = decorateCallableWithNumba(ingredientsFunction, parametersNumbaLight)
 
 	ingredientsModule = IngredientsModule(ingredientsFunction)
@@ -59,7 +59,7 @@ def makeMapFoldingNumba(astModule: ast.Module, identifierModule: str, identifier
 		ingredientsFunctionDispatcher.imports.update(shatteredDataclass.imports)
 		targetCallableIdentifier = ingredientsFunction.astFunctionDef.name
 		ingredientsFunctionDispatcher = unpackDataclassCallFunctionRepackDataclass(ingredientsFunctionDispatcher, targetCallableIdentifier, shatteredDataclass)
-		astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist(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 = Make.Store()
 
@@ -74,11 +74,11 @@ def makeMapFoldingNumba(astModule: ast.Module, identifierModule: str, identifier
 
 	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
-	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
+	ingredientsModule.write_astModule(pathFilename, identifierPackage=packageSettings.identifierPackage)
 
 	return pathFilename
 
-def makeTheorem2(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
+def makeTheorem2(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None, identifiers: Default | None = None) -> PurePath:
 	"""Generate module by applying optimization predicted by Theorem 2.
 
 	Parameters
@@ -99,19 +99,17 @@ def makeTheorem2(astModule: ast.Module, identifierModule: str, identifierCallabl
 	pathFilename : PurePath
 		Filesystem path where the theorem-optimized module was written.
 	"""
-	identifierCallableInitializeDataclassHARDCODED = 'transitionOnGroupsOfFolds'
-	identifierModuleInitializeDataclassHARDCODED = 'initializeState'
+	dictionaryIdentifiers = identifiers or default
+	identifierCallableInitializeDataclass = dictionaryIdentifiers['function']['initializeState']
+	identifierModuleInitializeDataclass = dictionaryIdentifiers['module']['initializeState']
 
-	identifierCallableInitializeDataclass = identifierCallableInitializeDataclassHARDCODED
-	identifierModuleInitializeDataclass = identifierModuleInitializeDataclassHARDCODED
-
-	sourceCallableIdentifier = default['function']['counting']
+	sourceCallableIdentifier = dictionaryIdentifiers['function']['counting']
 	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
 	ingredientsFunction.astFunctionDef.name = identifierCallable or sourceCallableIdentifier
 
 	dataclassInstanceIdentifier: str = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
 
-	theCountingIdentifier: str = default['variable']['counting']
+	theCountingIdentifier: str = dictionaryIdentifiers['variable']['counting']
 	doubleTheCount: ast.AugAssign = Make.AugAssign(Make.Attribute(Make.Name(dataclassInstanceIdentifier), theCountingIdentifier), Make.Mult(), Make.Constant(2))
 
 	NodeChanger(
@@ -160,7 +158,7 @@ def makeTheorem2(astModule: ast.Module, identifierModule: str, identifierCallabl
 
 		# Update any calls to the original function name with the new target function name
 		NodeChanger(
-			findThis = Be.Call.funcIs(Be.Name.idIs(IfThis.isIdentifier(default['function']['counting'])))
+			findThis = Be.Call.funcIs(Be.Name.idIs(IfThis.isIdentifier(dictionaryIdentifiers['function']['counting'])))
 			, doThat = Grab.funcAttribute(Grab.idAttribute(Then.replaceWith(targetCallableIdentifier)))
 		).visit(ingredientsFunctionDispatcher.astFunctionDef)
 
@@ -176,7 +174,7 @@ def makeTheorem2(astModule: ast.Module, identifierModule: str, identifierCallabl
 
 	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
-	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
+	ingredientsModule.write_astModule(pathFilename, identifierPackage=packageSettings.identifierPackage)
 
 	return pathFilename
 
@@ -212,7 +210,7 @@ def numbaOnTheorem2(astModule: ast.Module, identifierModule: str, identifierCall
 
 	ingredientsFunction.imports.update(shatteredDataclass.imports)
 	ingredientsFunction: IngredientsFunction = removeDataclassFromFunction(ingredientsFunction, shatteredDataclass)
-	ingredientsFunction = removeUnusedParameters(ingredientsFunction)
+	ingredientsFunction.removeUnusedParameters()
 	ingredientsFunction = decorateCallableWithNumba(ingredientsFunction, parametersNumbaLight)
 
 	ingredientsModule = IngredientsModule(ingredientsFunction)
@@ -223,7 +221,7 @@ def numbaOnTheorem2(astModule: ast.Module, identifierModule: str, identifierCall
 		ingredientsFunctionDispatcher.imports.update(shatteredDataclass.imports)
 		targetCallableIdentifier = ingredientsFunction.astFunctionDef.name
 		ingredientsFunctionDispatcher = unpackDataclassCallFunctionRepackDataclass(ingredientsFunctionDispatcher, targetCallableIdentifier, shatteredDataclass)
-		astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist(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 = Make.Store()
 
@@ -238,7 +236,7 @@ def numbaOnTheorem2(astModule: ast.Module, identifierModule: str, identifierCall
 
 	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
-	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
+	ingredientsModule.write_astModule(pathFilename, identifierPackage=packageSettings.identifierPackage)
 
 	return pathFilename
 
@@ -292,7 +290,7 @@ def trimTheorem2(astModule: ast.Module, identifierModule: str, identifierCallabl
 
 	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
-	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
+	ingredientsModule.write_astModule(pathFilename, identifierPackage=packageSettings.identifierPackage)
 
 	return pathFilename
 

mapFolding/someAssemblyRequired/makingModules_doTheNeedful.py

@@ -1,16 +1,15 @@
 """Make functions that are complementary to the `count` function and are often called by `doTheNeedful`."""
-from astToolkit import (
-	Be, DOT, Grab, identifierDotAttribute, IngredientsFunction, IngredientsModule, LedgerOfImports, NodeChanger,
-	NodeTourist, Then)
-from astToolkit.transformationTools import inlineFunctionDef, write_astModule
+from astToolkit import Be, DOT, Grab, identifierDotAttribute, NodeChanger, NodeTourist, Then
+from astToolkit.containers import IngredientsFunction, IngredientsModule, LedgerOfImports
+from astToolkit.transformationTools import inlineFunctionDef
 from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
-from mapFolding.someAssemblyRequired import default, IfThis
+from mapFolding.someAssemblyRequired import default, Default, IfThis
 from mapFolding.someAssemblyRequired.toolkitMakeModules import getPathFilename
 from pathlib import PurePath
 import ast
 
-def makeInitializeState(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
+def makeInitializeState(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None, identifiers: Default | None = None) -> PurePath:  # noqa: ARG001
 	"""Generate initialization module for counting variable setup.
 
 	(AI generated docstring)
@@ -42,18 +41,19 @@ def makeInitializeState(astModule: ast.Module, moduleIdentifier: str, callableId
 		Filesystem path where the initialization module was written.
 
 	"""
-	sourceCallableIdentifier: identifierDotAttribute = default['function']['counting']
+	dictionaryIdentifiers: Default = identifiers or default
+	sourceCallableIdentifier: identifierDotAttribute = dictionaryIdentifiers['function']['counting']
 	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
 	ingredientsFunction.astFunctionDef.name = callableIdentifier or sourceCallableIdentifier
 
 	dataclassInstanceIdentifier: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
-	theCountingIdentifier: identifierDotAttribute = default['variable']['counting']
+	theCountingIdentifier: identifierDotAttribute = dictionaryIdentifiers['variable']['counting']
 
 	findThis = IfThis.isWhileAttributeNamespaceIdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Grab.testAttribute(Grab.andDoAllOf([Grab.opsAttribute(Then.replaceWith([ast.Eq()])), Grab.leftAttribute(Grab.attrAttribute(Then.replaceWith(theCountingIdentifier)))]))
 	NodeChanger(findThis, doThat).visit(ingredientsFunction.astFunctionDef.body[0])
 
 	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
-	write_astModule(IngredientsModule(ingredientsFunction), pathFilename, packageSettings.identifierPackage)
+	IngredientsModule(ingredientsFunction).write_astModule(pathFilename, identifierPackage=packageSettings.identifierPackage)
 
 	return pathFilename

mapFolding/someAssemblyRequired/mapFoldingModules/makeMapFoldingModules.py

@@ -1,8 +1,9 @@
 """makeMapFoldingModules."""
 from astToolkit import (
-	astModuleToIngredientsFunction, Be, DOT, extractClassDef, Grab, hasDOTbody, identifierDotAttribute,
-	IngredientsFunction, IngredientsModule, LedgerOfImports, Make, NodeChanger, NodeTourist, parseLogicalPath2astModule,
-	parsePathFilename2astModule, Then)
+	Be, DOT, extractClassDef, Grab, hasDOTbody, identifierDotAttribute, Make, NodeChanger, NodeTourist,
+	parseLogicalPath2astModule, parsePathFilename2astModule, Then)
+from astToolkit.containers import (
+	astModuleToIngredientsFunction, IngredientsFunction, IngredientsModule, LedgerOfImports)
 from astToolkit.transformationTools import inlineFunctionDef, removeUnusedParameters, write_astModule
 from hunterMakesPy import importLogicalPath2Identifier, raiseIfNone
 from mapFolding import packageSettings
@@ -126,7 +127,7 @@ def makeDaoOfMapFoldingParallelNumba(astModule: ast.Module, identifierModule: st
 
 # END add the parallel logic to the count function ------------------------------------------------
 
-	ingredientsFunction = removeUnusedParameters(ingredientsFunction)
+	ingredientsFunction.removeUnusedParameters()
 
 	ingredientsFunction = decorateCallableWithNumba(ingredientsFunction, parametersNumbaLight)
 
@@ -186,7 +187,7 @@ def makeDaoOfMapFoldingParallelNumba(astModule: ast.Module, identifierModule: st
 
 	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
-	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
+	ingredientsModule.write_astModule(pathFilename, packageSettings.identifierPackage)
 
 	return pathFilename
 

mapFolding/someAssemblyRequired/meanders/makeMeandersModules.py

@@ -1,11 +1,11 @@
 """makeMeandersModules."""
-from astToolkit import (
-	astModuleToIngredientsFunction, Be, Grab, identifierDotAttribute, Make, NodeChanger, NodeTourist, Then)
+from astToolkit import Be, Grab, identifierDotAttribute, Make, NodeChanger, NodeTourist, Then
+from astToolkit.containers import astModuleToIngredientsFunction
+from astToolkit.transformationTools import write_astModule
 from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
 from mapFolding.someAssemblyRequired import default, IfThis
-from mapFolding.someAssemblyRequired.toolkitMakeModules import (
-	findDataclass, getModule, getPathFilename, write_astModule)
+from mapFolding.someAssemblyRequired.toolkitMakeModules import findDataclass, getModule, getPathFilename
 from pathlib import PurePath
 import ast
 
@@ -51,14 +51,14 @@ def makeCountBigInt(astModule: ast.Module, identifierModule: str, callableIdenti
 
 	pathFilename: PurePath = getPathFilename(logicalPathInfix=logicalPathInfix, identifierModule=identifierModule)
 
-	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
+	write_astModule(astModule, pathFilename, identifierPackage=packageSettings.identifierPackage)
 
 	return pathFilename
 
 def makeMeandersModules() -> None:
 	"""Make meanders modules."""
 	astModule: ast.Module = getModule(logicalPathInfix='algorithms', identifierModule='matrixMeanders')
-	pathFilename: PurePath = makeCountBigInt(astModule, 'bigInt', 'countBigInt', logicalPathInfixMeanders, default['function']['dispatcher'])
+	pathFilename: PurePath = makeCountBigInt(astModule, 'bigInt', 'countBigInt', logicalPathInfixMeanders, default['function']['dispatcher'])  # pyright: ignore[reportUnusedVariable] # noqa: F841
 
 if __name__ == '__main__':
 	makeMeandersModules()