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

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()

mapFolding/someAssemblyRequired/toolkitMakeModules.py

@@ -31,18 +31,14 @@ improvements through just-in-time compilation, parallel execution, and optimized
 tailored for specific computational requirements essential to large-scale map folding research.
 """
 
-from astToolkit import (
-	Be, DOT, identifierDotAttribute, IngredientsFunction, NodeTourist, parseLogicalPath2astModule, Then)
-from autoflake import fix_code as autoflake_fix_code
-from hunterMakesPy import raiseIfNone, writeStringToHere
+from astToolkit import Be, DOT, identifierDotAttribute, NodeTourist, parseLogicalPath2astModule, Then
+from astToolkit.containers import IngredientsFunction
+from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
 from mapFolding.someAssemblyRequired import default
 from os import PathLike
 from pathlib import PurePath
-from typing import Any
 import ast
-import io
-import isort
 
 def findDataclass(ingredientsFunction: IngredientsFunction) -> tuple[identifierDotAttribute, str, str]:
 	"""Dynamically extract information about a `dataclass`: the instance identifier, the identifier, and the logical path module.
@@ -128,25 +124,3 @@ def getPathFilename(pathRoot: PathLike[str] | PurePath | None = packageSettings.
 	if pathRoot:
 		pathFilename = PurePath(pathRoot, pathFilename)
 	return pathFilename
-
-def write_astModule(astModule: ast.Module, pathFilename: PathLike[Any] | PurePath | io.TextIOBase, packageName: str | None = None) -> None:
-	"""Prototype that will likely be moved to astToolkit.
-
-	Parameters
-	----------
-	astModule : ast.Module
-		The AST module to be written to a file.
-	pathFilename : PathLike[Any] | PurePath
-		The file path where the module should be written.
-	packageName : str | None = None
-		Optional package name to preserve in import optimization.
-	"""
-	ast.fix_missing_locations(astModule)
-	pythonSource: str = ast.unparse(astModule)
-	autoflake_additional_imports: list[str] = []
-	if packageName:
-		autoflake_additional_imports.append(packageName)
-	pythonSource = autoflake_fix_code(pythonSource, autoflake_additional_imports, expand_star_imports=False, remove_all_unused_imports=True, remove_duplicate_keys = False, remove_unused_variables = False)
-	pythonSource = isort.code(pythonSource)
-	writeStringToHere(pythonSource + '\n', pathFilename)
-

mapFolding/someAssemblyRequired/toolkitNumba.py

@@ -25,7 +25,8 @@ computational modules. The compilation layer integrates seamlessly with the broa
 system to produce standalone modules optimized for specific map dimensions and computational contexts.
 """
 
-from astToolkit import identifierDotAttribute, IngredientsFunction, Make
+from astToolkit import identifierDotAttribute, Make
+from astToolkit.containers import IngredientsFunction
 from collections.abc import Callable
 from numba.core.compiler import CompilerBase as numbaCompilerBase
 from typing import Any, Final, NotRequired, TYPE_CHECKING, TypedDict

mapFolding/someAssemblyRequired/transformationTools.py

@@ -25,9 +25,8 @@ This approach enables seamless integration between high-level dataclass-based in
 low-level optimized implementations, maintaining code clarity while achieving performance gains
 through specialized compilation paths essential for computationally intensive map folding research.
 """
-
-from astToolkit import (
-	Be, extractClassDef, identifierDotAttribute, IngredientsFunction, Make, NodeChanger, parseLogicalPath2astModule, Then)
+from astToolkit import Be, extractClassDef, identifierDotAttribute, Make, NodeChanger, parseLogicalPath2astModule, Then
+from astToolkit.containers import IngredientsFunction, LedgerOfImports
 from astToolkit.transformationTools import unparseFindReplace
 from hunterMakesPy import importLogicalPath2Identifier
 from mapFolding.someAssemblyRequired import DeReConstructField2ast, IfThis, ShatteredDataclass

mapFolding/syntheticModules/A007822/algorithm.py

@@ -1,8 +1,5 @@
-import numpy
-
 from mapFolding.dataBaskets import SymmetricFoldsState
 
-
 def filterAsymmetricFolds(state: SymmetricFoldsState) -> SymmetricFoldsState:
     state.indexLeaf = 1
     state.leafComparison[0] = 1
@@ -12,10 +9,13 @@ def filterAsymmetricFolds(state: SymmetricFoldsState) -> SymmetricFoldsState:
         state.leafComparison[state.leafConnectee] = (state.indexMiniGap - state.indexLeaf + state.leavesTotal) % state.leavesTotal
         state.indexLeaf = state.indexMiniGap
         state.leafConnectee += 1
-    state.arrayGroupOfFolds = numpy.take(state.leafComparison, state.indicesArrayGroupOfFolds)
-    compared = state.arrayGroupOfFolds[..., 0:state.leavesTotal // 2] == state.arrayGroupOfFolds[..., state.leavesTotal // 2:None]
-    for indexRow in range(len(compared)):
-        state.groupsOfFolds += compared[indexRow].all()
+    for listTuples in state.indices:
+        state.leafConnectee = 1
+        for indexLeft, indexRight in listTuples:
+            if state.leafComparison[indexLeft] != state.leafComparison[indexRight]:
+                state.leafConnectee = 0
+                break
+        state.symmetricFolds += state.leafConnectee
     return state
 
 def activeLeafGreaterThan0(state: SymmetricFoldsState) -> bool:
@@ -153,7 +153,7 @@ def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
             state = undoLastLeafPlacement(state)
         if gapAvailable(state):
             state = insertActiveLeafAtGap(state)
-    state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
+    state.symmetricFolds = (state.symmetricFolds + 1) // 2
     return state
 
 def doTheNeedful(state: SymmetricFoldsState) -> SymmetricFoldsState:

mapFolding/syntheticModules/A007822/asynchronous.py

@@ -1,11 +1,8 @@
 from copy import deepcopy
-from queue import Queue
-from threading import Lock, Thread
-
-import numpy
-
 from mapFolding import DatatypeFoldsTotal
 from mapFolding.dataBaskets import SymmetricFoldsState
+from queue import Queue
+from threading import Lock, Thread
 
 listThreads: list[Thread] = []
 queueFutures: Queue[SymmetricFoldsState] = Queue()
@@ -33,7 +30,7 @@ def _threadDoesSomething() -> None:
             break
         state = _filterAsymmetricFolds(state)
         with LOCKsymmetricFoldsTotal:
-            symmetricFoldsTotal += state.groupsOfFolds
+            symmetricFoldsTotal += state.symmetricFolds
 
 def filterAsymmetricFolds(state: SymmetricFoldsState) -> None:
     queueFutures.put_nowait(deepcopy(state))
@@ -54,11 +51,13 @@ def _filterAsymmetricFolds(state: SymmetricFoldsState) -> SymmetricFoldsState:
         state.leafComparison[state.leafConnectee] = (state.indexMiniGap - state.indexLeaf + state.leavesTotal) % state.leavesTotal
         state.indexLeaf = state.indexMiniGap
         state.leafConnectee += 1
-    state.arrayGroupOfFolds = numpy.take(state.leafComparison, state.indicesArrayGroupOfFolds)
-    state.indexMiniGap = 0
-    while state.indexMiniGap < len(state.arrayGroupOfFolds):
-        state.groupsOfFolds += int(numpy.all(numpy.equal(state.arrayGroupOfFolds[state.indexMiniGap, slice(0, state.leavesTotal // 2)], state.arrayGroupOfFolds[state.indexMiniGap, slice(state.leavesTotal // 2, None)])))
-        state.indexMiniGap += 1
+    for listTuples in state.indices:
+        state.leafConnectee = 1
+        for indexLeft, indexRight in listTuples:
+            if state.leafComparison[indexLeft] != state.leafComparison[indexRight]:
+                state.leafConnectee = 0
+                break
+        state.symmetricFolds += state.leafConnectee
     return state
 
 def activeLeafGreaterThan0(state: SymmetricFoldsState) -> bool:
@@ -197,8 +196,8 @@ def count(state: SymmetricFoldsState) -> SymmetricFoldsState:
         if gapAvailable(state):
             state = insertActiveLeafAtGap(state)
     else:
-        state.groupsOfFolds = getSymmetricFoldsTotal()
-    state.groupsOfFolds = (state.groupsOfFolds + 1) // 2
+        state.symmetricFolds = getSymmetricFoldsTotal()
+    state.symmetricFolds = (state.symmetricFolds + 1) // 2
     return state
 
 def doTheNeedful(state: SymmetricFoldsState, maxWorkers: int) -> SymmetricFoldsState: