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

mapFolding/someAssemblyRequired/A007822/A007822rawMaterials.py

@@ -1,54 +1,19 @@
 from astToolkit import extractFunctionDef, Make  # noqa: D100
 from hunterMakesPy import raiseIfNone
-from mapFolding.someAssemblyRequired import (
-	identifierCallableSourceDEFAULT, identifierCallableSourceDispatcherDEFAULT, identifierCountingDEFAULT,
-	identifierDataclassInstanceDEFAULT, logicalPathInfixDEFAULT)
+from mapFolding.someAssemblyRequired import defaultA007822
+from mapFolding.someAssemblyRequired.toolkitMakeModules import getModule
 import ast
 
-identifierDataclass: str = identifierDataclassInstanceDEFAULT
-identifierCounting: str = identifierCountingDEFAULT
-logicalPathInfixA007822: str = logicalPathInfixDEFAULT + '.A007822'
-sourceCallableDispatcherA007822: str = identifierCallableSourceDispatcherDEFAULT
-sourceCallableIdentifierA007822: str = identifierCallableSourceDEFAULT
+FunctionDef_filterAsymmetricFolds: ast.FunctionDef = raiseIfNone(extractFunctionDef(getModule(logicalPathInfix='algorithms', identifierModule='symmetricFolds'), defaultA007822['function']['filterAsymmetricFolds']))
 
-identifier_filterAsymmetricFolds = 'filterAsymmetricFolds'
-
-ImaString = f"""
-def {identifier_filterAsymmetricFolds}({identifierDataclass}: MapFoldingState) -> MapFoldingState:
-	{identifierDataclass}.indexLeaf = 0
-	leafConnectee = 0
-	while leafConnectee < {identifierDataclass}.leavesTotal + 1:
-		leafNumber = int({identifierDataclass}.leafBelow[{identifierDataclass}.indexLeaf])
-		{identifierDataclass}.leafComparison[leafConnectee] = (leafNumber - {identifierDataclass}.indexLeaf + {identifierDataclass}.leavesTotal) % {identifierDataclass}.leavesTotal
-		{identifierDataclass}.indexLeaf = leafNumber
-		leafConnectee += 1
-
-	indexInMiddle = {identifierDataclass}.leavesTotal // 2
-	{identifierDataclass}.indexMiniGap = 0
-	while {identifierDataclass}.indexMiniGap < {identifierDataclass}.leavesTotal + 1:
-		ImaSymmetricFold = True
-		leafConnectee = 0
-		while leafConnectee < indexInMiddle:
-			if {identifierDataclass}.leafComparison[({identifierDataclass}.indexMiniGap + leafConnectee) % ({identifierDataclass}.leavesTotal + 1)] != {identifierDataclass}.leafComparison[({identifierDataclass}.indexMiniGap + {identifierDataclass}.leavesTotal - 1 - leafConnectee) % ({identifierDataclass}.leavesTotal + 1)]:
-				ImaSymmetricFold = False
-				break
-			leafConnectee += 1
-		{identifierDataclass}.{identifierCounting} += ImaSymmetricFold
-		{identifierDataclass}.indexMiniGap += 1
-
-	return {identifierDataclass}
-"""  # noqa: E501
-
-FunctionDef_filterAsymmetricFolds: ast.FunctionDef = raiseIfNone(extractFunctionDef(ast.parse(ImaString), identifier_filterAsymmetricFolds))
-del ImaString
-
-ImaString = f"{identifierDataclass} = {identifier_filterAsymmetricFolds}({identifierDataclass})"
+ImaString: str = f"{defaultA007822['variable']['stateInstance']} = {defaultA007822['function']['filterAsymmetricFolds']}({defaultA007822['variable']['stateInstance']})"
 A007822incrementCount = ast.parse(ImaString).body[0]
 del ImaString
 
-ImaString = f'{identifierDataclass}.{identifierCounting} = ({identifierDataclass}.{identifierCounting} + 1) // 2'
-A007822adjustFoldsTotal = ast.parse(ImaString).body[0]
+ImaString = f'{defaultA007822['variable']['stateInstance']}.{defaultA007822['variable']['counting']} = ({defaultA007822['variable']['stateInstance']}.{defaultA007822['variable']['counting']} + 1) // 2'
+A007822adjustFoldsTotal: ast.stmt = ast.parse(ImaString).body[0]
 del ImaString
 
-astExprCall_filterAsymmetricFoldsDataclass: ast.Expr = Make.Expr(Make.Call(Make.Name(identifier_filterAsymmetricFolds), listParameters=[Make.Attribute(Make.Name(identifierDataclass), 'leafBelow')]))
-astExprCall_filterAsymmetricFoldsLeafBelow: ast.Expr = Make.Expr(Make.Call(Make.Name(identifier_filterAsymmetricFolds), listParameters=[Make.Name('leafBelow')]))
+ExprCallFilterAsymmetricFolds_leafBelow: ast.Expr = Make.Expr(Make.Call(Make.Name(defaultA007822['function']['filterAsymmetricFolds']), listParameters=[Make.Name('leafBelow')]))
+ExprCallFilterAsymmetricFoldsState: ast.Expr = Make.Expr(Make.Call(Make.Name(defaultA007822['function']['filterAsymmetricFolds']), listParameters=[Make.Name(defaultA007822['variable']['stateInstance'])]))
+ExprCallFilterAsymmetricFoldsStateDot_leafBelow: ast.Expr = Make.Expr(Make.Call(Make.Name(defaultA007822['function']['filterAsymmetricFolds']), listParameters=[Make.Attribute(Make.Name(defaultA007822['variable']['stateInstance']), 'leafBelow')]))

mapFolding/someAssemblyRequired/A007822/_asynchronousAnnex.py

@@ -0,0 +1,51 @@
+# NOTE The real module is generated from this incomplete module. Comments are not preserved.
+# ruff: noqa: PLW0603
+from copy import deepcopy
+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()
+symmetricFoldsTotal: int = 0
+LOCKsymmetricFoldsTotal = Lock()
+# TODO There isn't a better way to do this?
+STOPsignal = object()
+
+def initializeConcurrencyManager(maxWorkers: int, symmetricFolds: int=0) -> None:
+	global listThreads, symmetricFoldsTotal, queueFutures
+	listThreads = []
+	queueFutures = Queue()
+	symmetricFoldsTotal = symmetricFolds
+
+	indexThread = 0
+	while indexThread < maxWorkers:
+		thread = Thread(target=_threadDoesSomething, name=f"thread{indexThread}", daemon=True)
+		thread.start()
+		listThreads.append(thread)
+		indexThread += 1
+
+def _threadDoesSomething() -> None:
+	global symmetricFoldsTotal
+	while True:
+		state = queueFutures.get()
+		if state is STOPsignal:
+			break
+		state = _filterAsymmetricFolds(state)
+		with LOCKsymmetricFoldsTotal:
+			symmetricFoldsTotal += state.groupsOfFolds
+
+def _filterAsymmetricFolds(state: SymmetricFoldsState) -> SymmetricFoldsState:
+	"""Add real function during generation; the signature is here to preview its interactions with the module."""
+	return state
+
+def filterAsymmetricFolds(state: SymmetricFoldsState) -> None:
+	queueFutures.put_nowait(deepcopy(state))
+
+def getSymmetricFoldsTotal() -> DatatypeFoldsTotal:
+	for _thread in listThreads:
+		queueFutures.put(STOPsignal)  # pyright: ignore[reportArgumentType]
+	for thread in listThreads:
+		thread.join()
+	return symmetricFoldsTotal

mapFolding/someAssemblyRequired/A007822/makeA007822AsynchronousModules.py

@@ -1,30 +1,23 @@
 """addSymmetryCheckAsynchronous."""
-from astToolkit import Be, extractFunctionDef, Grab, Make, NodeChanger, NodeTourist, parsePathFilename2astModule, Then
+from astToolkit import Be, Grab, identifierDotAttribute, LedgerOfImports, Make, NodeChanger, NodeTourist, Then
 from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
-from mapFolding.someAssemblyRequired import IfThis, logicalPathInfixAlgorithmDEFAULT
-from mapFolding.someAssemblyRequired.A007822.A007822rawMaterials import (
-	A007822adjustFoldsTotal, astExprCall_filterAsymmetricFoldsDataclass, identifier_filterAsymmetricFolds,
-	identifierCounting, identifierDataclass, logicalPathInfixA007822, sourceCallableDispatcherA007822,
-	sourceCallableIdentifierA007822)
-from mapFolding.someAssemblyRequired.makingModules_count import makeTheorem2, numbaOnTheorem2, trimTheorem2
+from mapFolding.someAssemblyRequired import defaultA007822, IfThis
+from mapFolding.someAssemblyRequired.A007822.A007822rawMaterials import ExprCallFilterAsymmetricFoldsState
 from mapFolding.someAssemblyRequired.toolkitMakeModules import getModule, getPathFilename, write_astModule
-from os import PathLike
 from pathlib import PurePath
 import ast
 
-identifier_getAsymmetricFoldsTotal = 'getAsymmetricFoldsTotal'
-identifier_initializeConcurrencyManager = 'initializeConcurrencyManager'
-identifier_processCompletedFutures = '_processCompletedFutures'
+# TODO figure out asynchronous + numba.
 
-astExprCall_initializeConcurrencyManager: ast.Expr = Make.Expr(Make.Call(Make.Name(identifier_initializeConcurrencyManager)))
+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_getAsymmetricFoldsTotal))
+	[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, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
-	"""Add symmetry check to the counting function.
+def addSymmetryCheckAsynchronous(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute  | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
+	"""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.
@@ -39,16 +32,13 @@ def addSymmetryCheckAsynchronous(astModule: ast.Module, moduleIdentifier: str, c
 	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'))
@@ -56,9 +46,10 @@ def addSymmetryCheckAsynchronous(astModule: ast.Module, moduleIdentifier: str, c
 	).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))
@@ -66,132 +57,44 @@ def addSymmetryCheckAsynchronous(astModule: ast.Module, moduleIdentifier: str, c
 		).captureLastMatch(astModule))
 
 	astFunctionDef_doTheNeedful.body.insert(0, astExprCall_initializeConcurrencyManager)
+	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(f'{packageSettings.identifierPackage}.{logicalPathInfix}.{moduleIdentifier}Annex'
-			, [Make.alias(identifier_filterAsymmetricFolds), Make.alias(identifier_getAsymmetricFoldsTotal), Make.alias(identifier_initializeConcurrencyManager)], 0)
-
-	astModule.body.insert(0, astImportFrom)
-
-	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
-	pathFilenameAnnex: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier + 'Annex')
+	imports = LedgerOfImports(astModule)
+	removeImports = NodeChanger(IfThis.isAnyOf(Be.ImportFrom, Be.Import), Then.removeIt)
+	removeImports.visit(astModule)
 
-	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
+	astModuleAsynchronousAnnex: ast.Module = getModule(logicalPathInfix=defaultA007822['logicalPath']['assembly'], identifierModule='_asynchronousAnnex')
+	imports.walkThis(astModuleAsynchronousAnnex)
+	removeImports.visit(astModuleAsynchronousAnnex)
 
-	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_getAsymmetricFoldsTotal}() -> 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_getAsymmetricFoldsTotal)))
-	del ImaString
-
-	write_astModule(astModule, pathFilenameAnnex, packageSettings.identifierPackage)
+	NodeChanger(Be.FunctionDef.nameIs(IfThis.isIdentifier(defaultA007822['function']['filterAsymmetricFolds']))
+			, Grab.nameAttribute(Then.replaceWith(f"_{defaultA007822['function']['filterAsymmetricFolds']}"))
+		).visit(astModule)
 
-	return pathFilename
+	NodeChanger(Be.FunctionDef.nameIs(IfThis.isIdentifier(f"_{defaultA007822['function']['filterAsymmetricFolds']}"))
+			, Then.removeIt
+		).visit(astModuleAsynchronousAnnex)
 
-def _makeA007822AsynchronousModules() -> None:
+	astModule.body = [*imports.makeList_ast(), *astModuleAsynchronousAnnex.body, *astModule.body]
 
-	astModule = getModule(logicalPathInfix=logicalPathInfixAlgorithmDEFAULT)
-	pathFilename = addSymmetryCheckAsynchronous(astModule, 'asynchronous', None, logicalPathInfixA007822, sourceCallableDispatcherA007822)
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
-	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, moduleIdentifier='asynchronous')
-	pathFilename = makeTheorem2(astModule, 'asynchronousTheorem2', None, logicalPathInfixA007822, None)
+	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
 
-	astModule = parsePathFilename2astModule(pathFilename)
-	pathFilename = trimTheorem2(astModule, 'asynchronousTrimmed', None, logicalPathInfixA007822, None)
+	return pathFilename
 
-	astModule = parsePathFilename2astModule(pathFilename)
-	pathFilename = numbaOnTheorem2(astModule, 'asynchronousNumba', None, logicalPathInfixA007822, None)
+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,74 +1,73 @@
 """addSymmetryCheck."""
-from astToolkit import Be, Make, NodeChanger, NodeTourist, parsePathFilename2astModule, Then
+from astToolkit import (
+	Be, Grab, identifierDotAttribute, LedgerOfImports, NodeChanger, NodeTourist, parsePathFilename2astModule, Then)
 from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
-from mapFolding.someAssemblyRequired import (
-	identifierCallableSourceDEFAULT, 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 (
-	makeDaoOfMapFoldingNumba, 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, write_astModule
 from pathlib import PurePath
 import ast
 
-def addSymmetryCheck(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | 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.
+def addSymmetryCheck(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
+	"""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, moduleIdentifier)
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
 	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
 
 	return pathFilename
 
-def _makeA007822Modules() -> None:
-	astModule = getModule(logicalPathInfix='algorithms')
-	pathFilename = addSymmetryCheck(astModule, 'algorithm', None, logicalPathInfixA007822, None)
-
-	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, moduleIdentifier='algorithm')
-	pathFilename: PurePath = makeDaoOfMapFoldingNumba(astModule, 'algorithmNumba', None, logicalPathInfixA007822, sourceCallableDispatcherA007822)
+def makeA007822Modules() -> None:
+	"""Make."""
+	astModule: ast.Module = getModule(logicalPathInfix='algorithms')
+	pathFilename: PurePath = addSymmetryCheck(astModule, defaultA007822['module']['algorithm'], defaultA007822['function']['counting']
+		, defaultA007822['logicalPath']['synthetic'], None)
 
-	# NOTE I can't handle parallel right now.
+	astModule = getModule(logicalPathInfix=defaultA007822['logicalPath']['synthetic'], identifierModule=defaultA007822['module']['algorithm'])
+	makeInitializeState(astModule, defaultA007822['module']['initializeState']
+		, defaultA007822['function']['initializeState'], defaultA007822['logicalPath']['synthetic'], None)
 
-	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, moduleIdentifier='algorithm')
-	makeInitializeState(astModule, 'initializeState', 'transitionOnGroupsOfFolds', logicalPathInfixA007822)
-
-	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, moduleIdentifier='algorithm')
-	pathFilename = makeTheorem2(astModule, 'theorem2', None, logicalPathInfixA007822, None)
+	astModule = getModule(logicalPathInfix=defaultA007822['logicalPath']['synthetic'], identifierModule=defaultA007822['module']['algorithm'])
+	pathFilename = makeTheorem2(astModule, 'theorem2', defaultA007822['function']['counting']
+		, defaultA007822['logicalPath']['synthetic'], defaultA007822['function']['dispatcher'])
 
 	astModule = parsePathFilename2astModule(pathFilename)
-	pathFilename = trimTheorem2(astModule, 'theorem2Trimmed', None, logicalPathInfixA007822, None)
+	pathFilename = trimTheorem2(astModule, 'theorem2Trimmed', defaultA007822['function']['counting']
+		, defaultA007822['logicalPath']['synthetic'], defaultA007822['function']['dispatcher'])
 
 	astModule = parsePathFilename2astModule(pathFilename)
-	pathFilename = numbaOnTheorem2(astModule, 'theorem2Numba', None, logicalPathInfixA007822, None)
-# TODO from mapFolding.syntheticModules.dataPackingA007822 import unRePackDataclass
-# @unRePackDataclass
-
-# TODO Make this decorator.
-	# astImportFrom: ast.ImportFrom = Make.ImportFrom(getLogicalPath(packageSettings.identifierPackage, logicalPathInfixA007822, 'theorem2Numba'), list_alias=[Make.alias(sourceCallableIdentifierA007822)])
-	# makeUnRePackDataclass(astImportFrom, 'dataPackingA007822')
+	pathFilename = numbaOnTheorem2(astModule, 'theorem2Numba', defaultA007822['function']['counting']
+		, defaultA007822['logicalPath']['synthetic'], defaultA007822['function']['dispatcher'])
 
 if __name__ == '__main__':
-	_makeA007822Modules()
+	makeA007822Modules()

mapFolding/someAssemblyRequired/RecipeJob.py

@@ -1,17 +1,23 @@
 """Configuration by dataclass."""
 
-from ast import Module
-from astToolkit import identifierDotAttribute, parseLogicalPath2astModule
+from astToolkit import identifierDotAttribute, IngredientsFunction, IngredientsModule, parseLogicalPath2astModule
+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.someAssemblyRequired import DatatypeConfiguration, default
+from mapFolding.someAssemblyRequired._toolkitContainers import 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.
 
@@ -88,17 +94,17 @@ class RecipeJobTheorem2:
 	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 +112,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 +122,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
+	countCallable: 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
@@ -211,5 +217,59 @@ class RecipeJobTheorem2:
 		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.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