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

mapFolding/someAssemblyRequired/A007822/makeA007822AsynchronousModules.py

@@ -1,36 +1,25 @@
 """addSymmetryCheckAsynchronous."""
-from astToolkit import (
-	Be, extractFunctionDef, Grab, identifierDotAttribute, Make, NodeChanger, NodeTourist, parsePathFilename2astModule,
-	Then)
+from astToolkit import Be, Grab, identifierDotAttribute, Make, NodeChanger, NodeTourist, Then
+from astToolkit.containers import LedgerOfImports
+from astToolkit.transformationTools import write_astModule
 from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
-from mapFolding.someAssemblyRequired import (
-	identifierCallableSourceDispatcherDEFAULT, identifierCountingDEFAULT, identifierDataclassInstanceDEFAULT, IfThis,
-	logicalPathInfixAlgorithmDEFAULT)
-from mapFolding.someAssemblyRequired.A007822.A007822rawMaterials import (
-	A007822adjustFoldsTotal, astExprCall_filterAsymmetricFoldsDataclass, identifier_filterAsymmetricFolds,
-	identifierCounting, identifierDataclass, logicalPathInfixA007822, sourceCallableDispatcherA007822,
-	sourceCallableIdentifierA007822)
-from mapFolding.someAssemblyRequired.infoBooth import identifierCallableSourceDEFAULT
-from mapFolding.someAssemblyRequired.makingModules_count import makeTheorem2, numbaOnTheorem2, trimTheorem2
-from mapFolding.someAssemblyRequired.toolkitMakeModules import (
-	getLogicalPath, getModule, getPathFilename, write_astModule)
+from mapFolding.someAssemblyRequired import defaultA007822, IfThis
+from mapFolding.someAssemblyRequired.A007822.A007822rawMaterials import ExprCallFilterAsymmetricFoldsState
+from mapFolding.someAssemblyRequired.toolkitMakeModules import getModule, getPathFilename
 from pathlib import PurePath
 import ast
 
-identifier_asynchronous = 'asynchronous'
-identifier_getSymmetricFoldsTotal = 'getSymmetricFoldsTotal'
-identifier_initializeConcurrencyManager = 'initializeConcurrencyManager'
-identifier_processCompletedFutures = '_processCompletedFutures'
+# TODO figure out asynchronous + numba.
 
-astExprCall_initializeConcurrencyManager: ast.Expr = Make.Expr(Make.Call(Make.Name(identifier_initializeConcurrencyManager), listParameters=[Make.Name('maxWorkers')]))
+astExprCall_initializeConcurrencyManager: ast.Expr = Make.Expr(Make.Call(Make.Name(defaultA007822['function']['initializeConcurrencyManager']), listParameters=[Make.Name('maxWorkers')]))
 AssignTotal2CountingIdentifier: ast.Assign = Make.Assign(
-	[Make.Attribute(Make.Name(identifierDataclass), identifierCounting, context=Make.Store())]
-	, value=Make.Call(Make.Name(identifier_getSymmetricFoldsTotal))
+	[Make.Attribute(Make.Name(defaultA007822['variable']['stateInstance']), defaultA007822['variable']['counting'], context=Make.Store())]
+	, value=Make.Call(Make.Name(defaultA007822['function']['getSymmetricFoldsTotal']))
 )
 
 def addSymmetryCheckAsynchronous(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute  | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
-	"""Add symmetry check to the counting function.
+	"""Make the check for symmetry in each folding pattern in a group of folds asynchronous to the rest of the symmetric map folding algorithm.
 
 	To do asynchronous filtering, a few things must happen.
 	1. When the algorithm finds a `groupOfFolds`, the call to `filterAsymmetricFolds` must be non-blocking.
@@ -45,16 +34,13 @@ def addSymmetryCheckAsynchronous(astModule: ast.Module, identifierModule: str, i
 	Each `leafBelow` array will be 28 * 8-bits, so if the queue has only 0.3% of the total calls in it, that is 28 GiB of data.
 	"""
 	astFunctionDef_count: ast.FunctionDef = raiseIfNone(NodeTourist(
-		findThis = Be.FunctionDef.nameIs(IfThis.isIdentifier(sourceCallableIdentifierA007822))
+		findThis = Be.FunctionDef.nameIs(IfThis.isIdentifier(defaultA007822['function']['counting']))
 		, doThat = Then.extractIt
 		).captureLastMatch(astModule))
 
-	NodeChanger(Be.Return, Then.insertThisAbove([A007822adjustFoldsTotal])).visit(astFunctionDef_count)
-
 	NodeChanger(
-		findThis=Be.AugAssign.targetIs(IfThis.isAttributeNamespaceIdentifier(identifierDataclass, identifierCounting))
-		, doThat=Then.replaceWith(astExprCall_filterAsymmetricFoldsDataclass)
-		).visit(astFunctionDef_count)
+		Be.Assign.valueIs(IfThis.isCallIdentifier(defaultA007822['function']['filterAsymmetricFolds']))
+		, Then.replaceWith(ExprCallFilterAsymmetricFoldsState)).visit(astFunctionDef_count)
 
 	NodeChanger(
 		findThis=Be.While.testIs(IfThis.isCallIdentifier('activeLeafGreaterThan0'))
@@ -62,9 +48,10 @@ def addSymmetryCheckAsynchronous(astModule: ast.Module, identifierModule: str, i
 	).visit(astFunctionDef_count)
 
 	NodeChanger(
-		findThis=Be.FunctionDef.nameIs(IfThis.isIdentifier(sourceCallableIdentifierA007822))
+		findThis=Be.FunctionDef.nameIs(IfThis.isIdentifier(defaultA007822['function']['counting']))
 		, doThat=Then.replaceWith(astFunctionDef_count)
 		).visit(astModule)
+	del astFunctionDef_count
 
 	astFunctionDef_doTheNeedful: ast.FunctionDef = raiseIfNone(NodeTourist(
 		findThis = Be.FunctionDef.nameIs(IfThis.isIdentifier(sourceCallableDispatcher))
@@ -72,188 +59,44 @@ def addSymmetryCheckAsynchronous(astModule: ast.Module, identifierModule: str, i
 		).captureLastMatch(astModule))
 
 	astFunctionDef_doTheNeedful.body.insert(0, astExprCall_initializeConcurrencyManager)
-	astFunctionDef_doTheNeedful.args.args.append(Make.arg('maxWorkers', Make.BitOr.join([Make.Name('int'), Make.Constant(None)])))
-	astFunctionDef_doTheNeedful.args.defaults.append(Make.Constant(None))
+	astFunctionDef_doTheNeedful.args.args.append(Make.arg('maxWorkers', Make.Name('int')))
 
 	NodeChanger(
 		findThis=Be.FunctionDef.nameIs(IfThis.isIdentifier(sourceCallableDispatcher))
 		, doThat=Then.replaceWith(astFunctionDef_doTheNeedful)
 		).visit(astModule)
+	del astFunctionDef_doTheNeedful
 
-	astImportFrom = ast.ImportFrom(getLogicalPath(packageSettings.identifierPackage, logicalPathInfix, identifierModule + 'Annex')
-			, [Make.alias(identifier_filterAsymmetricFolds), Make.alias(identifier_getSymmetricFoldsTotal), Make.alias(identifier_initializeConcurrencyManager)], 0)
-
-	astModule.body.insert(0, astImportFrom)
-
-	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
-	pathFilenameAnnex: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule + 'Annex')
-
-	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
-	del astModule
-# ----------------- Ingredients Module Annex ------------------------------------------------------------------------------
-	ImaString = """from concurrent.futures import Future as ConcurrentFuture, ThreadPoolExecutor
-from hunterMakesPy import raiseIfNone
-from mapFolding import Array1DLeavesTotal
-from queue import Empty, Queue
-from threading import Thread
-import numpy"""
-
-	astModule = ast.parse(ImaString)
-	del ImaString
-
-	ImaString = f"""concurrencyManager = None
-{identifierCounting}Total: int = 0
-processingThread = None
-queueFutures: Queue[ConcurrentFuture[int]] = Queue()
-	"""
-	astModule.body.extend(ast.parse(ImaString).body)
-	del ImaString
-
-	ImaString = f"""def {identifier_initializeConcurrencyManager}(maxWorkers: int | None = None, {identifierCounting}: int = 0) -> None:
-	global concurrencyManager, queueFutures, {identifierCounting}Total, processingThread
-	concurrencyManager = ThreadPoolExecutor(max_workers=maxWorkers)
-	queueFutures = Queue()
-	{identifierCounting}Total = {identifierCounting}
-	processingThread = Thread(target={identifier_processCompletedFutures})
-	processingThread.start()
-	"""
-	astModule.body.append(raiseIfNone(extractFunctionDef(ast.parse(ImaString), identifier_initializeConcurrencyManager)))
-	del ImaString
-
-	ImaString = f"""def {identifier_processCompletedFutures}() -> None:
-	global queueFutures, {identifierCounting}Total
-	while True:
-		try:
-			claimTicket: ConcurrentFuture[int] = queueFutures.get(timeout=1)
-			if claimTicket is None:
-				break
-			{identifierCounting}Total += claimTicket.result()
-		except Empty:
-			continue
-	"""
-	astModule.body.append(raiseIfNone(extractFunctionDef(ast.parse(ImaString), identifier_processCompletedFutures)))
-	del ImaString
-
-	ImaString = f"""def _{identifier_filterAsymmetricFolds}(leafBelow: Array1DLeavesTotal) -> int:
-	{identifierCounting} = 0
-	leafComparison: Array1DLeavesTotal = numpy.zeros_like(leafBelow)
-	leavesTotal = leafBelow.size - 1
-
-	indexLeaf = 0
-	leafConnectee = 0
-	while leafConnectee < leavesTotal + 1:
-		leafNumber = int(leafBelow[indexLeaf])
-		leafComparison[leafConnectee] = (leafNumber - indexLeaf + leavesTotal) % leavesTotal
-		indexLeaf = leafNumber
-		leafConnectee += 1
-
-	indexInMiddle = leavesTotal // 2
-	indexDistance = 0
-	while indexDistance < leavesTotal + 1:
-		ImaSymmetricFold = True
-		leafConnectee = 0
-		while leafConnectee < indexInMiddle:
-			if leafComparison[(indexDistance + leafConnectee) % (leavesTotal + 1)] != leafComparison[(indexDistance + leavesTotal - 1 - leafConnectee) % (leavesTotal + 1)]:
-				ImaSymmetricFold = False
-				break
-			leafConnectee += 1
-		{identifierCounting} += ImaSymmetricFold
-		indexDistance += 1
-	return {identifierCounting}
-	"""
-	astModule.body.append(raiseIfNone(extractFunctionDef(ast.parse(ImaString), f'_{identifier_filterAsymmetricFolds}')))
-	del ImaString
+	imports = LedgerOfImports(astModule)
+	removeImports = NodeChanger(IfThis.isAnyOf(Be.ImportFrom, Be.Import), Then.removeIt)
+	removeImports.visit(astModule)
 
-	ImaString = f"""
-def {identifier_filterAsymmetricFolds}(leafBelow: Array1DLeavesTotal) -> None:
-	global concurrencyManager, queueFutures
-	queueFutures.put_nowait(raiseIfNone(concurrencyManager).submit(_{identifier_filterAsymmetricFolds}, leafBelow.copy()))
-	"""
-	astModule.body.append(raiseIfNone(extractFunctionDef(ast.parse(ImaString), identifier_filterAsymmetricFolds)))
-	del ImaString
-
-	ImaString = f"""
-def {identifier_getSymmetricFoldsTotal}() -> int:
-	global concurrencyManager, queueFutures, processingThread
-	raiseIfNone(concurrencyManager).shutdown(wait=True)
-	queueFutures.put(None)
-	raiseIfNone(processingThread).join()
-	return {identifierCounting}Total
-	"""
-	astModule.body.append(raiseIfNone(extractFunctionDef(ast.parse(ImaString), identifier_getSymmetricFoldsTotal)))
-	del ImaString
-	write_astModule(astModule, pathFilenameAnnex, packageSettings.identifierPackage)
-
-	return pathFilename
+	astModuleAsynchronousAnnex: ast.Module = getModule(logicalPathInfix=defaultA007822['logicalPath']['assembly'], identifierModule='_asynchronousAnnex')
+	imports.walkThis(astModuleAsynchronousAnnex)
+	removeImports.visit(astModuleAsynchronousAnnex)
 
-def makeAsynchronousNumbaOnTheorem2(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
-	"""Make the asynchronous numba on theorem2 module."""
-	pathFilename: PurePath = numbaOnTheorem2(astModule, identifierModule, identifierCallable, logicalPathInfix, sourceCallableDispatcher)
-
-	astModule = parsePathFilename2astModule(pathFilename)
-
-	listAssignToMove: list[ast.Assign] = []
-
-	findThis = IfThis.isAnyOf(IfThis.isAssignAndTargets0Is(IfThis.isNameIdentifier(identifierCountingDEFAULT))
-					, Be.AugAssign.targetIs(IfThis.isNameIdentifier(identifierCountingDEFAULT)))
-	NodeTourist(findThis, Then.appendTo(listAssignToMove)).visit(astModule)
-
-	NodeChanger(findThis, Then.removeIt).visit(astModule)
-
-	NodeChanger(
-		findThis=Be.Assign.valueIs(IfThis.isCallIdentifier(identifierCallableSourceDEFAULT))
-		, doThat=Then.insertThisBelow(listAssignToMove)
-	).visit(astModule)
-
-	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
-
-	return pathFilename
-
-def makeAsynchronousTheorem2(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
-	"""Make the asynchronous theorem2 module."""
-	pathFilename: PurePath = makeTheorem2(astModule, identifierModule, identifierCallable, logicalPathInfix, sourceCallableDispatcher)
-
-	astModule = parsePathFilename2astModule(pathFilename)
-
-	astAttribute = Make.Attribute(Make.Name(identifierDataclassInstanceDEFAULT), identifierCountingDEFAULT)
-	astAssign = Make.Assign([astAttribute], value=Make.Constant(0))
+	NodeChanger(Be.FunctionDef.nameIs(IfThis.isIdentifier(defaultA007822['function']['filterAsymmetricFolds']))
+			, Grab.nameAttribute(Then.replaceWith(f"_{defaultA007822['function']['filterAsymmetricFolds']}"))
+		).visit(astModule)
 
-	NodeChanger[ast.Call, ast.Call](
-		findThis = IfThis.isCallIdentifier(identifier_initializeConcurrencyManager)
-		, doThat = Grab.argsAttribute(lambda args: [*args, astAttribute]) # pyright: ignore[reportArgumentType]
-	).visit(astModule)
+	NodeChanger(Be.FunctionDef.nameIs(IfThis.isIdentifier(f"_{defaultA007822['function']['filterAsymmetricFolds']}"))
+			, Then.removeIt
+		).visit(astModuleAsynchronousAnnex)
 
-	NodeChanger(
-		findThis = Be.Expr.valueIs(IfThis.isCallIdentifier(identifier_initializeConcurrencyManager))
-		, doThat = Then.insertThisBelow([astAssign])
-	).visit(astModule)
+	astModule.body = [*imports.makeList_ast(), *astModuleAsynchronousAnnex.body, *astModule.body]
 
-	identifierAnnex: identifierDotAttribute = getLogicalPath(packageSettings.identifierPackage, logicalPathInfix, identifier_asynchronous + 'Annex')
-	identifierAnnexNumba: identifierDotAttribute = identifierAnnex + 'Numba'
-
-	NodeChanger(
-		findThis=Be.ImportFrom.moduleIs(IfThis.isIdentifier(identifierAnnex))
-		, doThat=Grab.moduleAttribute(Then.replaceWith(identifierAnnexNumba))
-	).visit(astModule)
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
-	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
+	write_astModule(astModule, pathFilename, identifierPackage=packageSettings.identifierPackage)
 
 	return pathFilename
 
-def _makeA007822AsynchronousModules() -> None:
-
-	astModule: ast.Module = getModule(logicalPathInfix=logicalPathInfixAlgorithmDEFAULT)
-	pathFilename: PurePath = addSymmetryCheckAsynchronous(astModule, 'asynchronous', None, logicalPathInfixA007822, sourceCallableDispatcherA007822)
-
-	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, identifierModule='asynchronous')
-	pathFilename = makeAsynchronousTheorem2(astModule, 'asynchronousTheorem2', None, logicalPathInfixA007822, identifierCallableSourceDispatcherDEFAULT)
-
-	astModule = parsePathFilename2astModule(pathFilename)
-	pathFilename = trimTheorem2(astModule, 'asynchronousTrimmed', None, logicalPathInfixA007822, identifierCallableSourceDispatcherDEFAULT)
-
-	astModule = parsePathFilename2astModule(pathFilename)
-	pathFilename = makeAsynchronousNumbaOnTheorem2(astModule, 'asynchronousNumba', None, logicalPathInfixA007822, identifierCallableSourceDispatcherDEFAULT)
+def makeA007822AsynchronousModules() -> None:
+	"""Make asynchronous modules for A007822."""
+	astModule: ast.Module = getModule(logicalPathInfix=defaultA007822['logicalPath']['synthetic'], identifierModule=defaultA007822['module']['algorithm'])
+	pathFilename: PurePath = addSymmetryCheckAsynchronous(astModule, defaultA007822['module']['asynchronous'], defaultA007822['function']['counting']  # noqa: F841 # pyright: ignore[reportUnusedVariable]
+		, defaultA007822['logicalPath']['synthetic'], defaultA007822['function']['dispatcher'])
 
 if __name__ == '__main__':
-	_makeA007822AsynchronousModules()
+	makeA007822AsynchronousModules()
 

mapFolding/someAssemblyRequired/A007822/makeA007822Modules.py

@@ -1,75 +1,89 @@
 """addSymmetryCheck."""
-from astToolkit import Be, identifierDotAttribute, Make, NodeChanger, NodeTourist, parsePathFilename2astModule, Then
+from astToolkit import (
+	Be, Grab, identifierDotAttribute, Make, NodeChanger, NodeTourist, parsePathFilename2astModule, Then)
+from astToolkit.containers import LedgerOfImports
+from astToolkit.transformationTools import write_astModule
 from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
-from mapFolding.someAssemblyRequired import (
-	identifierCallableSourceDEFAULT, identifierCallableSourceDispatcherDEFAULT, identifierCountingDEFAULT,
-	identifierDataclassInstanceDEFAULT, IfThis)
+from mapFolding.someAssemblyRequired import default, defaultA007822, IfThis
 from mapFolding.someAssemblyRequired.A007822.A007822rawMaterials import (
-	A007822adjustFoldsTotal, A007822incrementCount, FunctionDef_filterAsymmetricFolds, logicalPathInfixA007822,
-	sourceCallableDispatcherA007822, sourceCallableIdentifierA007822)
-from mapFolding.someAssemblyRequired.makingModules_count import (
-	makeMapFoldingNumba, makeTheorem2, numbaOnTheorem2, trimTheorem2)
-from mapFolding.someAssemblyRequired.makingModules_doTheNeedful import makeInitializeState, makeUnRePackDataclass
-from mapFolding.someAssemblyRequired.toolkitMakeModules import (
-	getLogicalPath, getModule, getPathFilename, write_astModule)
-from os import PathLike
+	A007822adjustFoldsTotal, A007822incrementCount, FunctionDef_filterAsymmetricFolds)
+from mapFolding.someAssemblyRequired.makingModules_count import makeTheorem2, numbaOnTheorem2, trimTheorem2
+from mapFolding.someAssemblyRequired.makingModules_doTheNeedful import makeInitializeState
+from mapFolding.someAssemblyRequired.toolkitMakeModules import getModule, getPathFilename
 from pathlib import PurePath
 import ast
 
 def addSymmetryCheck(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
-	"""Add logic to check for symmetric folds."""
-# NOTE HEY HEY! Are you trying to figure out why there is more than one copy of `filterAsymmetricFolds`? See the TODO NOTE, below.
+	"""Modify the multidimensional map folding algorithm by checking for symmetry in each folding pattern in a group of folds."""
+	NodeChanger(Be.Name.idIs(IfThis.isIdentifier(default['variable']['stateDataclass']))
+			, Grab.idAttribute(Then.replaceWith(defaultA007822['variable']['stateDataclass']))
+		).visit(astModule)
 
-	astFunctionDef_count: ast.FunctionDef = raiseIfNone(NodeTourist(
-		findThis = Be.FunctionDef.nameIs(IfThis.isIdentifier(identifierCallableSourceDEFAULT))
+	NodeChanger(Be.alias.nameIs(IfThis.isIdentifier(default['variable']['stateDataclass']))
+			, Grab.nameAttribute(Then.replaceWith(defaultA007822['variable']['stateDataclass']))
+		).visit(astModule)
+
+	FunctionDef_count: ast.FunctionDef = raiseIfNone(NodeTourist(
+		findThis = Be.FunctionDef.nameIs(IfThis.isIdentifier(default['function']['counting']))
 		, doThat = Then.extractIt
 		).captureLastMatch(astModule))
-	astFunctionDef_count.name = sourceCallableIdentifierA007822
+	FunctionDef_count.name = identifierCallable or defaultA007822['function']['counting']
 
-	NodeChanger(Be.Return, Then.insertThisAbove([A007822adjustFoldsTotal])).visit(astFunctionDef_count)
+	NodeChanger(Be.Return, Then.insertThisAbove([A007822adjustFoldsTotal])).visit(FunctionDef_count)
 
 	NodeChanger(
-		findThis=Be.AugAssign.targetIs(IfThis.isAttributeNamespaceIdentifier(identifierDataclassInstanceDEFAULT, identifierCountingDEFAULT))
+		findThis=Be.AugAssign.targetIs(IfThis.isAttributeNamespaceIdentifier(default['variable']['stateInstance'], default['variable']['counting']))
 		, doThat=Then.replaceWith(A007822incrementCount)
-		).visit(astFunctionDef_count)
+		).visit(FunctionDef_count)
+
+	imports = LedgerOfImports(astModule)
+	NodeChanger(IfThis.isAnyOf(Be.ImportFrom, Be.Import), Then.removeIt).visit(astModule)
+	imports.addImport_asStr('numpy')
 
-# TODO NOTE This will insert a copy of `filterAsymmetricFolds` for each `ast.ImportFrom` in the source module. Find or make a
-# system to replace the `Ingredients` paradigm.
-	NodeChanger(Be.ImportFrom, Then.insertThisBelow([FunctionDef_filterAsymmetricFolds])).visit(astModule)
+	astModule.body = [*imports.makeList_ast(), FunctionDef_filterAsymmetricFolds, *astModule.body]
 
 	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
-	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
+	write_astModule(astModule, pathFilename, identifierPackage=packageSettings.identifierPackage)
 
 	return pathFilename
 
-def _makeA007822Modules() -> None:
-	astModule = getModule(logicalPathInfix='algorithms')
-	pathFilename = addSymmetryCheck(astModule, 'algorithm', None, logicalPathInfixA007822, None)
+def _numbaOnTheorem2(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
+	pathFilename: PurePath = numbaOnTheorem2(astModule, identifierModule, identifierCallable, logicalPathInfix, sourceCallableDispatcher)
+	astModule = parsePathFilename2astModule(pathFilename)
+
+	NodeChanger(Be.AnnAssign.valueIs(IfThis.isAttributeNamespaceIdentifier(defaultA007822['variable']['stateInstance'], 'indices'))
+			, lambda node: Grab.valueAttribute(Then.replaceWith(Make.Call(Make.Name('List'), [raiseIfNone(node.value)])))(node)
+		).visit(astModule)
 
-	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, identifierModule='algorithm')
-	pathFilename: PurePath = makeMapFoldingNumba(astModule, 'algorithmNumba', None, logicalPathInfixA007822, sourceCallableDispatcherA007822)
+	astModule.body.insert(0, Make.ImportFrom('numba.typed', [Make.alias('List')]))
 
-	# NOTE I can't handle parallel right now.
+	write_astModule(astModule, pathFilename, identifierPackage=packageSettings.identifierPackage)
 
-	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, identifierModule='algorithm')
-	makeInitializeState(astModule, 'initializeState', 'transitionOnGroupsOfFolds', logicalPathInfixA007822)
+	return pathFilename
 
-	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, identifierModule='algorithm')
-	pathFilename = makeTheorem2(astModule, 'theorem2', None, logicalPathInfixA007822, identifierCallableSourceDispatcherDEFAULT)
+def makeA007822Modules() -> None:
+	"""Make."""
+	astModule: ast.Module = getModule(logicalPathInfix='algorithms')
+	pathFilename: PurePath = addSymmetryCheck(astModule, defaultA007822['module']['algorithm'], defaultA007822['function']['counting']
+		, defaultA007822['logicalPath']['synthetic'], None)
 
-	astModule = parsePathFilename2astModule(pathFilename)
-	pathFilename = trimTheorem2(astModule, 'theorem2Trimmed', None, logicalPathInfixA007822, identifierCallableSourceDispatcherDEFAULT)
+	astModule = getModule(logicalPathInfix=defaultA007822['logicalPath']['synthetic'], identifierModule=defaultA007822['module']['algorithm'])
+	makeInitializeState(astModule, defaultA007822['module']['initializeState']
+		, defaultA007822['function']['initializeState'], defaultA007822['logicalPath']['synthetic'], None, identifiers=defaultA007822)
+
+	astModule = getModule(logicalPathInfix=defaultA007822['logicalPath']['synthetic'], identifierModule=defaultA007822['module']['algorithm'])
+	pathFilename = makeTheorem2(astModule, 'theorem2', defaultA007822['function']['counting']
+		, defaultA007822['logicalPath']['synthetic'], defaultA007822['function']['dispatcher'], identifiers=defaultA007822)
 
 	astModule = parsePathFilename2astModule(pathFilename)
-	pathFilename = numbaOnTheorem2(astModule, 'theorem2Numba', None, logicalPathInfixA007822, identifierCallableSourceDispatcherDEFAULT)
-# TODO from mapFolding.syntheticModules.dataPackingA007822 import unRePackDataclass
-# @unRePackDataclass
+	pathFilename = trimTheorem2(astModule, 'theorem2Trimmed', defaultA007822['function']['counting']
+		, defaultA007822['logicalPath']['synthetic'], defaultA007822['function']['dispatcher'])
 
-# TODO Make this decorator.
-	# astImportFrom: ast.ImportFrom = Make.ImportFrom(getLogicalPath(packageSettings.identifierPackage, logicalPathInfixA007822, 'theorem2Numba'), list_alias=[Make.alias(sourceCallableIdentifierA007822)])
-	# makeUnRePackDataclass(astImportFrom, 'dataPackingA007822')
+	astModule = parsePathFilename2astModule(pathFilename)
+	pathFilename = _numbaOnTheorem2(astModule, 'theorem2Numba', defaultA007822['function']['counting']
+		, defaultA007822['logicalPath']['synthetic'], defaultA007822['function']['dispatcher'])
 
 if __name__ == '__main__':
-	_makeA007822Modules()
+	makeA007822Modules()

mapFolding/someAssemblyRequired/RecipeJob.py

@@ -1,33 +1,29 @@
 """Configuration by dataclass."""
 
-from ast import Module
 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
+# 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 identifierDataclassInstanceDEFAULT, 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
+import ast
 import dataclasses
 
-@dataclasses.dataclass
+@dataclasses.dataclass(slots=True)
 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
 	----------
@@ -81,24 +77,24 @@ 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."""
 	shatteredDataclass: ShatteredDataclass = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
 	"""Deconstructed dataclass metadata for code transformation."""
 
-	# Source -----------------------------------------
-	source_astModule: Module = parseLogicalPath2astModule('mapFolding.syntheticModules.theorem2Numba')  # noqa: RUF009
+# ------- Source -----------------------------------------
+	source_astModule: ast.Module = parseLogicalPath2astModule(f'{packageSettings.identifierPackage}.{default['logicalPath']['synthetic']}.theorem2Numba')  # noqa: RUF009
 	"""Parsed AST of the source module containing the generic algorithm."""
-	sourceCountCallable: str = 'count'
+	identifierCallableSource: str = default['function']['counting']
 	"""Name of the counting function to extract."""
 
-	sourceLogicalPathModuleDataclass: identifierDotAttribute = 'mapFolding.dataBaskets'
+	sourceLogicalPathModuleDataclass: identifierDotAttribute = f'{packageSettings.identifierPackage}.dataBaskets'
 	"""Logical path to the dataclass module."""
-	sourceDataclassIdentifier: str = 'MapFoldingState'
+	sourceDataclassIdentifier: str = default['variable']['stateDataclass']
 	"""Name of the source dataclass."""
-	sourceDataclassInstance: str = identifierDataclassInstanceDEFAULT
+	sourceDataclassInstance: str = default['variable']['stateInstance']
 	"""Instance identifier for the dataclass."""
 
 	sourcePathPackage: PurePosixPath | None = PurePosixPath(packageSettings.pathPackage)  # noqa: RUF009
@@ -106,7 +102,7 @@ class RecipeJobTheorem2:
 	sourcePackageIdentifier: str | None = packageSettings.identifierPackage
 	"""Name of the source package."""
 
-	# Filesystem, names of physical objects ------------------------------------------
+# ------- Filesystem, names of physical objects ------------------------------------------
 	pathPackage: PurePosixPath | None = None
 	"""Override path for the target package."""
 	pathModule: PurePosixPath | None = PurePosixPath(getPathRootJobDEFAULT())  # noqa: RUF009
@@ -116,23 +112,23 @@ class RecipeJobTheorem2:
 	pathFilenameFoldsTotal: PurePosixPath = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
 	"""Path for writing fold count results."""
 
-	# Logical identifiers, as opposed to physical identifiers ------------------------
+# ------- Logical identifiers, as opposed to physical identifiers ------------------------
 	packageIdentifier: str | None = None
 	"""Target package identifier."""
 	logicalPathRoot: identifierDotAttribute | None = None
 	"""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 = sourceCountCallable
+	identifierCallable: str = identifierCallableSource
 	"""Name of the counting function in generated module."""
-	dataclassIdentifier: str | None = sourceDataclassIdentifier
+	identifierDataclass: str | None = sourceDataclassIdentifier
 	"""Target dataclass identifier."""
-	dataclassInstance: str | None = sourceDataclassInstance
+	identifierDataclassInstance: str | None = sourceDataclassInstance
 	"""Target dataclass instance identifier."""
 	logicalPathModuleDataclass: identifierDotAttribute | None = sourceLogicalPathModuleDataclass
 	"""Logical path to target dataclass module."""
 
-	# Datatypes ------------------------------------------
+# ------- Datatypes ------------------------------------------
 	type DatatypeFoldsTotal = TheDatatypeFoldsTotal
 	"""Type alias for datatype linked to the magnitude of `foldsTotal`."""
 	type DatatypeElephino = TheDatatypeElephino
@@ -205,11 +201,65 @@ 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.shatteredDataclass is None and self.logicalPathModuleDataclass and self.dataclassIdentifier and self.dataclassInstance: # pyright: ignore[reportUnnecessaryComparison]
-			self.shatteredDataclass = shatter_dataclassesDOTdataclass(self.logicalPathModuleDataclass, self.dataclassIdentifier, self.dataclassInstance)
+		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)
+
+def moveShatteredDataclass_arg2body(identifier: str, job: RecipeJobTheorem2) -> ast.AnnAssign | ast.Assign:
+	"""Embed a shattered dataclass field assignment into the function body.
+
+	(AI generated docstring)
+
+	This helper retrieves the pre-fabricated assignment for `identifier` from `job.shatteredDataclass`, hydrates the literal
+	payload from `job.state`, and returns the node ready for insertion into a generated function body. Scalar entries receive the
+	concrete integer value, array entries are encoded using the auto-decoding run-length encoded method from `hunterMakesPy`, and
+	other constructors are left untouched so downstream tooling can decide how to finalize them.
+
+	Parameters
+	----------
+	identifier : str
+		Field name keyed in `job.shatteredDataclass.Z0Z_field2AnnAssign`.
+	job : RecipeJobTheorem2
+		Job descriptor that supplies the current computation state and shattered metadata.
+
+	Returns
+	-------
+	Ima___Assign : ast.AnnAssign | ast.Assign
+		Assignment node mutated with state-backed values for the requested field.
+	"""
+	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
+		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]
+		case _:
+			pass
+	return Ima___Assign
+
+# TODO Use this concept in general modules, not just custom jobs.
+def customizeDatatypeViaImport(ingredientsFunction: IngredientsFunction, ingredientsModule: IngredientsModule, listDatatypeConfigurations: list[DatatypeConfiguration]) -> tuple[IngredientsFunction, IngredientsModule]:
+	"""Customize data types in the given ingredients by adjusting imports.
+
+	In the ecosystem of "Ingredients", "Recipes", "DataBaskets," and "shattered dataclasses," a ton of code is dedicated to
+	preserving _abstract_ names for datatypes, such as `Array1DLeavesTotal` and `DatatypeFoldsTotal`. This function well
+	illustrates why I put so much effort into preserving the abstract names. (Normally, Python will _immediately_ replace an alias
+	name with the type for which it is a proxy.) Because transformed code, even if it has been through 10 transformations (see,
+	for example, `mapFolding.syntheticModules.A007822.asynchronousNumba` or its equivalent), ought to still have the abstract
+	names, this function gives you the power to change the datatype from numpy to numba and/or from 8-bits to 16-bits merely by
+	changing the import statements. You shouldn't need to change any "business" logic.
+
+	NOTE This will not remove potentially conflicting existing imports from other modules.
+	"""
+	for datatypeConfig in listDatatypeConfigurations:
+		ingredientsFunction.imports.removeImportFrom(datatypeConfig.typeModule, None, datatypeConfig.datatypeIdentifier)
+		ingredientsFunction.imports.addImportFrom_asStr(datatypeConfig.typeModule, datatypeConfig.typeIdentifier, datatypeConfig.type_asname)
+
+	return ingredientsFunction, ingredientsModule

mapFolding/someAssemblyRequired/__init__.py

@@ -73,20 +73,16 @@ 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,
-	identifierCallableSourceDEFAULT as identifierCallableSourceDEFAULT,
-	identifierCallableSourceDispatcherDEFAULT as identifierCallableSourceDispatcherDEFAULT,
-	identifierCountingDEFAULT as identifierCountingDEFAULT,
-	identifierDataclassInstanceDEFAULT as identifierDataclassInstanceDEFAULT,
-	identifierModuleDataPackingDEFAULT as identifierModuleDataPackingDEFAULT,
-	identifierModuleSourceAlgorithmDEFAULT as identifierModuleSourceAlgorithmDEFAULT,
-	logicalPathInfixAlgorithmDEFAULT as logicalPathInfixAlgorithmDEFAULT,
-	logicalPathInfixDEFAULT as logicalPathInfixDEFAULT,
 )
 
 from mapFolding.someAssemblyRequired._toolIfThis import IfThis as IfThis
 
 from mapFolding.someAssemblyRequired._toolkitContainers import (
+	DatatypeConfiguration as DatatypeConfiguration,
 	DeReConstructField2ast as DeReConstructField2ast,
 	ShatteredDataclass as ShatteredDataclass,
 )