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

mapFolding/someAssemblyRequired/A007822/A007822rawMaterials.py

@@ -1,4 +1,4 @@
-from astToolkit import extractFunctionDef, Make  # noqa: D100
+from astToolkit import extractFunctionDef, identifierDotAttribute, Make  # noqa: D100
 from hunterMakesPy import raiseIfNone
 from mapFolding.someAssemblyRequired import (
 	identifierCallableSourceDEFAULT, identifierCallableSourceDispatcherDEFAULT, identifierCountingDEFAULT,
@@ -7,7 +7,7 @@ import ast
 
 identifierDataclass: str = identifierDataclassInstanceDEFAULT
 identifierCounting: str = identifierCountingDEFAULT
-logicalPathInfixA007822: str = logicalPathInfixDEFAULT + '.A007822'
+logicalPathInfixA007822: identifierDotAttribute = logicalPathInfixDEFAULT + '.A007822'
 sourceCallableDispatcherA007822: str = identifierCallableSourceDispatcherDEFAULT
 sourceCallableIdentifierA007822: str = identifierCallableSourceDEFAULT
 

mapFolding/someAssemblyRequired/A007822/makeA007822AsynchronousModules.py

@@ -1,29 +1,35 @@
 """addSymmetryCheckAsynchronous."""
-from astToolkit import Be, extractFunctionDef, Grab, Make, NodeChanger, NodeTourist, parsePathFilename2astModule, Then
+from astToolkit import (
+	Be, extractFunctionDef, Grab, identifierDotAttribute, Make, NodeChanger, NodeTourist, parsePathFilename2astModule,
+	Then)
 from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
-from mapFolding.someAssemblyRequired import IfThis, logicalPathInfixAlgorithmDEFAULT
+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 getModule, getPathFilename, write_astModule
-from os import PathLike
+from mapFolding.someAssemblyRequired.toolkitMakeModules import (
+	getLogicalPath, getModule, getPathFilename, write_astModule)
 from pathlib import PurePath
 import ast
 
-identifier_getAsymmetricFoldsTotal = 'getAsymmetricFoldsTotal'
+identifier_asynchronous = 'asynchronous'
+identifier_getSymmetricFoldsTotal = 'getSymmetricFoldsTotal'
 identifier_initializeConcurrencyManager = 'initializeConcurrencyManager'
 identifier_processCompletedFutures = '_processCompletedFutures'
 
-astExprCall_initializeConcurrencyManager: ast.Expr = Make.Expr(Make.Call(Make.Name(identifier_initializeConcurrencyManager)))
+astExprCall_initializeConcurrencyManager: ast.Expr = Make.Expr(Make.Call(Make.Name(identifier_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))
+	, value=Make.Call(Make.Name(identifier_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
+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.
 
 	To do asynchronous filtering, a few things must happen.
@@ -66,19 +72,21 @@ 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.BitOr.join([Make.Name('int'), Make.Constant(None)])))
+	astFunctionDef_doTheNeedful.args.defaults.append(Make.Constant(None))
 
 	NodeChanger(
 		findThis=Be.FunctionDef.nameIs(IfThis.isIdentifier(sourceCallableDispatcher))
 		, doThat=Then.replaceWith(astFunctionDef_doTheNeedful)
 		).visit(astModule)
 
-	astImportFrom = ast.ImportFrom(f'{packageSettings.identifierPackage}.{logicalPathInfix}.{moduleIdentifier}Annex'
-			, [Make.alias(identifier_filterAsymmetricFolds), Make.alias(identifier_getAsymmetricFoldsTotal), Make.alias(identifier_initializeConcurrencyManager)], 0)
+	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, moduleIdentifier)
-	pathFilenameAnnex: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier + 'Annex')
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
+	pathFilenameAnnex: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule + 'Annex')
 
 	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
 	del astModule
@@ -165,33 +173,87 @@ def {identifier_filterAsymmetricFolds}(leafBelow: Array1DLeavesTotal) -> None:
 	del ImaString
 
 	ImaString = f"""
-def {identifier_getAsymmetricFoldsTotal}() -> int:
+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_getAsymmetricFoldsTotal)))
+	astModule.body.append(raiseIfNone(extractFunctionDef(ast.parse(ImaString), identifier_getSymmetricFoldsTotal)))
 	del ImaString
-
 	write_astModule(astModule, pathFilenameAnnex, packageSettings.identifierPackage)
 
 	return pathFilename
 
+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[ast.Call, ast.Call](
+		findThis = IfThis.isCallIdentifier(identifier_initializeConcurrencyManager)
+		, doThat = Grab.argsAttribute(lambda args: [*args, astAttribute]) # pyright: ignore[reportArgumentType]
+	).visit(astModule)
+
+	NodeChanger(
+		findThis = Be.Expr.valueIs(IfThis.isCallIdentifier(identifier_initializeConcurrencyManager))
+		, doThat = Then.insertThisBelow([astAssign])
+	).visit(astModule)
+
+	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)
+
+	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
+
+	return pathFilename
+
 def _makeA007822AsynchronousModules() -> None:
 
-	astModule = getModule(logicalPathInfix=logicalPathInfixAlgorithmDEFAULT)
-	pathFilename = addSymmetryCheckAsynchronous(astModule, 'asynchronous', None, logicalPathInfixA007822, sourceCallableDispatcherA007822)
+	astModule: ast.Module = getModule(logicalPathInfix=logicalPathInfixAlgorithmDEFAULT)
+	pathFilename: PurePath = addSymmetryCheckAsynchronous(astModule, 'asynchronous', None, logicalPathInfixA007822, sourceCallableDispatcherA007822)
 
-	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, moduleIdentifier='asynchronous')
-	pathFilename = makeTheorem2(astModule, 'asynchronousTheorem2', None, logicalPathInfixA007822, None)
+	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, identifierModule='asynchronous')
+	pathFilename = makeAsynchronousTheorem2(astModule, 'asynchronousTheorem2', None, logicalPathInfixA007822, identifierCallableSourceDispatcherDEFAULT)
 
 	astModule = parsePathFilename2astModule(pathFilename)
-	pathFilename = trimTheorem2(astModule, 'asynchronousTrimmed', None, logicalPathInfixA007822, None)
+	pathFilename = trimTheorem2(astModule, 'asynchronousTrimmed', None, logicalPathInfixA007822, identifierCallableSourceDispatcherDEFAULT)
 
 	astModule = parsePathFilename2astModule(pathFilename)
-	pathFilename = numbaOnTheorem2(astModule, 'asynchronousNumba', None, logicalPathInfixA007822, None)
+	pathFilename = makeAsynchronousNumbaOnTheorem2(astModule, 'asynchronousNumba', None, logicalPathInfixA007822, identifierCallableSourceDispatcherDEFAULT)
 
 if __name__ == '__main__':
 	_makeA007822AsynchronousModules()
+

mapFolding/someAssemblyRequired/A007822/makeA007822Modules.py

@@ -1,14 +1,15 @@
 """addSymmetryCheck."""
-from astToolkit import Be, Make, NodeChanger, NodeTourist, parsePathFilename2astModule, Then
+from astToolkit import Be, identifierDotAttribute, Make, NodeChanger, NodeTourist, parsePathFilename2astModule, Then
 from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
 from mapFolding.someAssemblyRequired import (
-	identifierCallableSourceDEFAULT, identifierCountingDEFAULT, identifierDataclassInstanceDEFAULT, IfThis)
+	identifierCallableSourceDEFAULT, identifierCallableSourceDispatcherDEFAULT, identifierCountingDEFAULT,
+	identifierDataclassInstanceDEFAULT, IfThis)
 from mapFolding.someAssemblyRequired.A007822.A007822rawMaterials import (
 	A007822adjustFoldsTotal, A007822incrementCount, FunctionDef_filterAsymmetricFolds, logicalPathInfixA007822,
 	sourceCallableDispatcherA007822, sourceCallableIdentifierA007822)
 from mapFolding.someAssemblyRequired.makingModules_count import (
-	makeDaoOfMapFoldingNumba, makeTheorem2, numbaOnTheorem2, trimTheorem2)
+	makeMapFoldingNumba, makeTheorem2, numbaOnTheorem2, trimTheorem2)
 from mapFolding.someAssemblyRequired.makingModules_doTheNeedful import makeInitializeState, makeUnRePackDataclass
 from mapFolding.someAssemblyRequired.toolkitMakeModules import (
 	getLogicalPath, getModule, getPathFilename, write_astModule)
@@ -16,7 +17,7 @@ from os import PathLike
 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
+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.
 
@@ -37,7 +38,7 @@ def addSymmetryCheck(astModule: ast.Module, moduleIdentifier: str, callableIdent
 # system to replace the `Ingredients` paradigm.
 	NodeChanger(Be.ImportFrom, Then.insertThisBelow([FunctionDef_filterAsymmetricFolds])).visit(astModule)
 
-	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
 	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
 
@@ -47,22 +48,22 @@ 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)
+	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, identifierModule='algorithm')
+	pathFilename: PurePath = makeMapFoldingNumba(astModule, 'algorithmNumba', None, logicalPathInfixA007822, sourceCallableDispatcherA007822)
 
 	# NOTE I can't handle parallel right now.
 
-	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, moduleIdentifier='algorithm')
+	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, identifierModule='algorithm')
 	makeInitializeState(astModule, 'initializeState', 'transitionOnGroupsOfFolds', logicalPathInfixA007822)
 
-	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, moduleIdentifier='algorithm')
-	pathFilename = makeTheorem2(astModule, 'theorem2', None, logicalPathInfixA007822, None)
+	astModule = getModule(logicalPathInfix=logicalPathInfixA007822, identifierModule='algorithm')
+	pathFilename = makeTheorem2(astModule, 'theorem2', None, logicalPathInfixA007822, identifierCallableSourceDispatcherDEFAULT)
 
 	astModule = parsePathFilename2astModule(pathFilename)
-	pathFilename = trimTheorem2(astModule, 'theorem2Trimmed', None, logicalPathInfixA007822, None)
+	pathFilename = trimTheorem2(astModule, 'theorem2Trimmed', None, logicalPathInfixA007822, identifierCallableSourceDispatcherDEFAULT)
 
 	astModule = parsePathFilename2astModule(pathFilename)
-	pathFilename = numbaOnTheorem2(astModule, 'theorem2Numba', None, logicalPathInfixA007822, None)
+	pathFilename = numbaOnTheorem2(astModule, 'theorem2Numba', None, logicalPathInfixA007822, identifierCallableSourceDispatcherDEFAULT)
 # TODO from mapFolding.syntheticModules.dataPackingA007822 import unRePackDataclass
 # @unRePackDataclass
 

mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py

@@ -327,11 +327,11 @@ if __name__ == '__main__':
 	"""
 
 if __name__ == '__main__':
-	state = transitionOnGroupsOfFolds(MapFoldingState((1,27)))
+	state = transitionOnGroupsOfFolds(MapFoldingState((2,5)))
 	pathModule = PurePosixPath(packageSettings.pathPackage, 'jobs')
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
 	aJob = RecipeJobTheorem2(state, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
-	spices = SpicesJobNumba(useNumbaProgressBar=False, parametersNumba=parametersNumbaLight)
+	spices = SpicesJobNumba(useNumbaProgressBar=True, parametersNumba=parametersNumbaLight)
 	makeJobNumba(aJob, spices)
 
 # TODO Improve this module with lessons learned in `makeJobTheorem2codon`.

mapFolding/someAssemblyRequired/makingModules_count.py

@@ -11,8 +11,7 @@ from hunterMakesPy import raiseIfNone
 from mapFolding import packageSettings
 from mapFolding.someAssemblyRequired import (
 	identifierCallableSourceDEFAULT, identifierCountingDEFAULT, IfThis, ShatteredDataclass)
-from mapFolding.someAssemblyRequired.A007822.A007822rawMaterials import astExprCall_filterAsymmetricFoldsLeafBelow
-from mapFolding.someAssemblyRequired.toolkitMakeModules import findDataclass, getPathFilename
+from mapFolding.someAssemblyRequired.toolkitMakeModules import findDataclass, getLogicalPath, getPathFilename
 from mapFolding.someAssemblyRequired.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight
 from mapFolding.someAssemblyRequired.transformationTools import (
 	removeDataclassFromFunction, shatter_dataclassesDOTdataclass, unpackDataclassCallFunctionRepackDataclass)
@@ -21,29 +20,16 @@ from pathlib import PurePath
 from typing import cast
 import ast
 
-def makeDaoOfMapFoldingNumba(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
-	"""Generate Numba-optimized sequential implementation of map folding algorithm.
-
-	(AI generated docstring)
-
-	Creates a high-performance sequential version of the map folding algorithm by
-	decomposing dataclass parameters into individual primitive values, removing
-	dataclass dependencies that are incompatible with Numba, applying Numba
-	decorators for just-in-time compilation, and optionally including a dispatcher
-	function for dataclass integration.
-
-	The generated module provides significant performance improvements over the
-	original dataclass-based implementation while maintaining algorithmic correctness.
-	The transformation preserves all computational logic while restructuring data
-	access patterns for optimal Numba compilation.
+def makeMapFoldingNumba(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
+	"""Generate Numba-optimized sequential implementation of an algorithm.
 
 	Parameters
 	----------
 	astModule : ast.Module
 		Source module containing the base algorithm.
-	moduleIdentifier : str
+	identifierModule : str
 		Name for the generated optimized module.
-	callableIdentifier : str | None = None
+	identifierCallable : str | None = None
 		Name for the main computational function.
 	logicalPathInfix : PathLike[str] | PurePath | str | None = None
 		Directory path for organizing the generated module.
@@ -56,9 +42,9 @@ def makeDaoOfMapFoldingNumba(astModule: ast.Module, moduleIdentifier: str, calla
 		Filesystem path where the optimized module was written.
 
 	"""
-	sourceCallableIdentifier: identifierDotAttribute = identifierCallableSourceDEFAULT
+	sourceCallableIdentifier: str = identifierCallableSourceDEFAULT
 	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
-	ingredientsFunction.astFunctionDef.name = callableIdentifier or sourceCallableIdentifier
+	ingredientsFunction.astFunctionDef.name = identifierCallable or sourceCallableIdentifier
 
 	shatteredDataclass: ShatteredDataclass = shatter_dataclassesDOTdataclass(*findDataclass(ingredientsFunction))
 
@@ -88,46 +74,46 @@ def makeDaoOfMapFoldingNumba(astModule: ast.Module, moduleIdentifier: str, calla
 
 	ingredientsModule.removeImportFromModule('numpy')
 
-	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
 	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
 
 	return pathFilename
 
-def makeTheorem2(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | 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) -> PurePath:
 	"""Generate module by applying optimization predicted by Theorem 2.
 
 	Parameters
 	----------
 	astModule : ast.Module
 		Source module containing the base algorithm.
-	moduleIdentifier : str
+	identifierModule : str
 		Name for the generated theorem-optimized module.
-	callableIdentifier : str | None = None
+	identifierCallable : str | None = None
 		Name for the optimized computational function.
 	logicalPathInfix : PathLike[str] | PurePath | str | None = None
 		Directory path for organizing the generated module.
 	sourceCallableDispatcher : str | None = None
-		Currently not implemented for this transformation.
+		Optional dispatcher function identifier.
 
 	Returns
 	-------
 	pathFilename : PurePath
 		Filesystem path where the theorem-optimized module was written.
+	"""
+	identifierCallableInitializeDataclassHARDCODED = 'transitionOnGroupsOfFolds'
+	identifierModuleInitializeDataclassHARDCODED = 'initializeState'
 
-	Raises
-	------
-	NotImplementedError
-		If `sourceCallableDispatcher` is provided.
+	identifierCallableInitializeDataclass = identifierCallableInitializeDataclassHARDCODED
+	identifierModuleInitializeDataclass = identifierModuleInitializeDataclassHARDCODED
 
-	"""
 	sourceCallableIdentifier = identifierCallableSourceDEFAULT
 	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
-	ingredientsFunction.astFunctionDef.name = callableIdentifier or sourceCallableIdentifier
+	ingredientsFunction.astFunctionDef.name = identifierCallable or sourceCallableIdentifier
 
-	dataclassInstanceIdentifier: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
+	dataclassInstanceIdentifier: str = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
 
-	theCountingIdentifier: identifierDotAttribute = identifierCountingDEFAULT
+	theCountingIdentifier: str = identifierCountingDEFAULT
 	doubleTheCount: ast.AugAssign = Make.AugAssign(Make.Attribute(Make.Name(dataclassInstanceIdentifier), theCountingIdentifier), Make.Mult(), Make.Constant(2))
 
 	NodeChanger(
@@ -171,40 +157,41 @@ def makeTheorem2(astModule: ast.Module, moduleIdentifier: str, callableIdentifie
 	ingredientsModule = IngredientsModule(ingredientsFunction)
 
 	if sourceCallableDispatcher is not None:
-		message = 'sourceCallableDispatcher is not implemented yet'
-		raise NotImplementedError(message)
+		ingredientsFunctionDispatcher: IngredientsFunction = astModuleToIngredientsFunction(astModule, sourceCallableDispatcher)
+		targetCallableIdentifier = ingredientsFunction.astFunctionDef.name
 
-	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
+		# Update any calls to the original function name with the new target function name
+		NodeChanger(
+			findThis = Be.Call.funcIs(Be.Name.idIs(IfThis.isIdentifier(identifierCallableSourceDEFAULT)))
+			, doThat = Grab.funcAttribute(Grab.idAttribute(Then.replaceWith(targetCallableIdentifier)))
+		).visit(ingredientsFunctionDispatcher.astFunctionDef)
 
-	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
+		AssignInitializedDataclass: ast.Assign = Make.Assign([Make.Name(dataclassInstanceIdentifier)], value=Make.Call(Make.Name(identifierCallableInitializeDataclass), [Make.Name(dataclassInstanceIdentifier)]))
 
-	return pathFilename
+		# Insert the transitionOnGroupsOfFolds call at the beginning of the function
+		ingredientsFunctionDispatcher.astFunctionDef.body.insert(0, AssignInitializedDataclass)
 
-def numbaOnTheorem2(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
-	"""Generate Numba-accelerated Theorem 2 implementation with dataclass decomposition.
+		dotModule: identifierDotAttribute = getLogicalPath(packageSettings.identifierPackage, logicalPathInfix, identifierModuleInitializeDataclass)
+		ingredientsFunctionDispatcher.imports.addImportFrom_asStr(dotModule, identifierCallableInitializeDataclass)
 
-	(AI generated docstring)
+		ingredientsModule.appendIngredientsFunction(ingredientsFunctionDispatcher)
 
-	Creates a highly optimized version of the Theorem 2 algorithm by combining the
-	mathematical optimizations of Theorem 2 with Numba just-in-time compilation.
-	The transformation includes dataclass decomposition to convert structured
-	parameters into primitives, removal of Python object dependencies incompatible
-	with Numba, application of Numba decorators for maximum performance, and type
-	annotation optimization for efficient compilation.
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
-	This represents the highest level of optimization available for Theorem 2
-	implementations, providing both mathematical efficiency through theorem
-	application and computational efficiency through Numba acceleration.
-	The result is suitable for production use in high-performance computing
-	environments where maximum speed is required.
+	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
+
+	return pathFilename
+
+def numbaOnTheorem2(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
+	"""Generate Numba-accelerated Theorem 2 implementation with dataclass decomposition.
 
 	Parameters
 	----------
 	astModule : ast.Module
 		Source module containing the Theorem 2 implementation.
-	moduleIdentifier : str
+	identifierModule : str
 		Name for the generated Numba-accelerated module.
-	callableIdentifier : str | None = None
+	identifierCallable : str | None = None
 		Name for the accelerated computational function.
 	logicalPathInfix : PathLike[str] | PurePath | str | None = None
 		Directory path for organizing the generated module.
@@ -218,12 +205,12 @@ def numbaOnTheorem2(astModule: ast.Module, moduleIdentifier: str, callableIdenti
 
 	"""
 	sourceCallableIdentifier = identifierCallableSourceDEFAULT
-	if callableIdentifier is None:
-		callableIdentifier = sourceCallableIdentifier
 	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
-	ingredientsFunction.astFunctionDef.name = callableIdentifier
+	ingredientsFunction.astFunctionDef.name = identifierCallable or sourceCallableIdentifier
 
-	shatteredDataclass: ShatteredDataclass = shatter_dataclassesDOTdataclass(*findDataclass(ingredientsFunction))
+	logicalPathDataclass, identifierDataclass, identifierDataclassInstance = findDataclass(ingredientsFunction)
+
+	shatteredDataclass: ShatteredDataclass = shatter_dataclassesDOTdataclass(logicalPathDataclass, identifierDataclass, identifierDataclassInstance)
 
 	ingredientsFunction.imports.update(shatteredDataclass.imports)
 	ingredientsFunction: IngredientsFunction = removeDataclassFromFunction(ingredientsFunction, shatteredDataclass)
@@ -233,32 +220,40 @@ def numbaOnTheorem2(astModule: ast.Module, moduleIdentifier: str, callableIdenti
 	ingredientsModule = IngredientsModule(ingredientsFunction)
 	ingredientsModule.removeImportFromModule('numpy')
 
-	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
+	if sourceCallableDispatcher is not None:
+		ingredientsFunctionDispatcher: IngredientsFunction = astModuleToIngredientsFunction(astModule, sourceCallableDispatcher)
+		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)
+				, doThat=Then.extractIt(DOT.value)).captureLastMatch(ingredientsFunction.astFunctionDef)))
+		astTuple.ctx = Make.Store()
+
+		changeAssignCallToTarget = NodeChanger(
+			findThis = Be.Assign.valueIs(IfThis.isCallIdentifier(targetCallableIdentifier))
+			, doThat = Then.replaceWith(Make.Assign([astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts))))
+		changeAssignCallToTarget.visit(ingredientsFunctionDispatcher.astFunctionDef)
+
+		ingredientsModule.appendIngredientsFunction(ingredientsFunctionDispatcher)
+
+	ingredientsModule.removeImportFromModule('numpy')
+
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
 	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
 
 	return pathFilename
 
-def trimTheorem2(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
+def trimTheorem2(astModule: ast.Module, identifierModule: str, identifierCallable: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
 	"""Generate constrained Theorem 2 implementation by removing unnecessary logic.
 
-	(AI generated docstring)
-
-	Creates a trimmed version of the Theorem 2 implementation by eliminating conditional logic that is not needed under specific
-	constraint assumptions. This transformation removes checks for unconstrained dimensions, simplifying the algorithm for cases
-	where dimensional constraints are guaranteed to be satisfied by external conditions.
-
-	The trimming operation is particularly valuable for generating lean implementations where the calling context ensures that
-	certain conditions will always be met, allowing the removal of defensive programming constructs that add computational
-	overhead without providing benefits in the constrained environment.
-
 	Parameters
 	----------
 	astModule : ast.Module
 		Source module containing the Theorem 2 implementation.
-	moduleIdentifier : str
+	identifierModule : str
 		Name for the generated trimmed module.
-	callableIdentifier : str | None = None
+	identifierCallable : str | None = None
 		Name for the trimmed computational function.
 	logicalPathInfix : PathLike[str] | PurePath | str | None = None
 		Directory path for organizing the generated module.
@@ -271,20 +266,33 @@ def trimTheorem2(astModule: ast.Module, moduleIdentifier: str, callableIdentifie
 		Filesystem path where the trimmed module was written.
 
 	"""
-	sourceCallableIdentifier = identifierCallableSourceDEFAULT
+	sourceCallableIdentifier: str = identifierCallableSourceDEFAULT
 	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
-	ingredientsFunction.astFunctionDef.name = callableIdentifier or sourceCallableIdentifier
+	ingredientsFunction.astFunctionDef.name = identifierCallable or sourceCallableIdentifier
 
-	dataclassInstanceIdentifier: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
+	identifierDataclassInstance: str = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
 
-	findThis = IfThis.isIfUnaryNotAttributeNamespaceIdentifier(dataclassInstanceIdentifier, 'dimensionsUnconstrained')
-	doThat = Then.removeIt
-	NodeChanger(findThis, doThat).visit(ingredientsFunction.astFunctionDef)
+	NodeChanger(
+		findThis = IfThis.isIfUnaryNotAttributeNamespaceIdentifier(identifierDataclassInstance, 'dimensionsUnconstrained')
+		, doThat = Then.removeIt
+	).visit(ingredientsFunction.astFunctionDef)
 
 	ingredientsModule = IngredientsModule(ingredientsFunction)
 	ingredientsModule.removeImportFromModule('numpy')
 
-	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
+	if sourceCallableDispatcher is not None:
+		ingredientsFunctionDispatcher: IngredientsFunction = astModuleToIngredientsFunction(astModule, sourceCallableDispatcher)
+		targetCallableIdentifier = ingredientsFunction.astFunctionDef.name
+
+		# Update any calls to the original function name with the new target function name
+		NodeChanger(
+			findThis = Be.Call.funcIs(Be.Name.idIs(IfThis.isIdentifier(identifierCallableSourceDEFAULT)))
+			, doThat = Grab.funcAttribute(Grab.idAttribute(Then.replaceWith(targetCallableIdentifier)))
+		).visit(ingredientsFunctionDispatcher.astFunctionDef)
+
+		ingredientsModule.appendIngredientsFunction(ingredientsFunctionDispatcher)
+
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
 	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
 

mapFolding/someAssemblyRequired/makingModules_doTheNeedful.py

@@ -17,7 +17,7 @@ from pathlib import PurePath
 from typing import cast
 import ast
 
-def makeInitializeState(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | 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) -> PurePath:  # noqa: ARG001
 	"""Generate initialization module for counting variable setup.
 
 	(AI generated docstring)
@@ -65,7 +65,7 @@ def makeInitializeState(astModule: ast.Module, moduleIdentifier: str, callableId
 
 	return pathFilename
 
-def makeUnRePackDataclass(astImportFrom: ast.ImportFrom, moduleIdentifier: str = identifierModuleDataPackingDEFAULT) -> None:
+def makeUnRePackDataclass(astImportFrom: ast.ImportFrom, moduleIdentifier: str = identifierModuleDataPackingDEFAULT) -> PurePath:
 	"""Generate interface module for dataclass unpacking and repacking operations.
 
 	Parameters
@@ -73,19 +73,21 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom, moduleIdentifier: str =
 	astImportFrom : ast.ImportFrom
 		Import statement specifying the target optimized function to call.
 
+	moduleIdentifier : str = identifierModuleDataPackingDEFAULT
+		Name for the generated interface module.
+
 	Returns
 	-------
-	None
-		The generated module is written directly to the filesystem.
-
+	pathFilename : PurePath
+		Filesystem path where the interface module was written.
 	"""
 	callableIdentifierHARDCODED: str = 'sequential'
 
 	algorithmSourceModule: identifierDotAttribute = identifierModuleSourceAlgorithmDEFAULT
-	callableIdentifier: identifierDotAttribute = callableIdentifierHARDCODED
+	callableIdentifier: str = callableIdentifierHARDCODED
 	logicalPathInfix: identifierDotAttribute = logicalPathInfixDEFAULT
 	logicalPathInfixAlgorithm: identifierDotAttribute = logicalPathInfixAlgorithmDEFAULT
-	sourceCallableIdentifier: identifierDotAttribute = identifierCallableSourceDispatcherDEFAULT
+	sourceCallableIdentifier: str = identifierCallableSourceDispatcherDEFAULT
 
 	logicalPathSourceModule: identifierDotAttribute = '.'.join([packageSettings.identifierPackage, logicalPathInfixAlgorithm, algorithmSourceModule])  # noqa: FLY002
 
@@ -115,3 +117,5 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom, moduleIdentifier: str =
 
 	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
 
+	return pathFilename
+

mapFolding/someAssemblyRequired/mapFolding/makeMapFoldingModules.py

@@ -10,7 +10,7 @@ from mapFolding.someAssemblyRequired import (
 	DeReConstructField2ast, identifierCallableSourceDEFAULT, identifierCallableSourceDispatcherDEFAULT, IfThis,
 	logicalPathInfixDEFAULT, ShatteredDataclass)
 from mapFolding.someAssemblyRequired.makingModules_count import (
-	makeDaoOfMapFoldingNumba, makeTheorem2, numbaOnTheorem2, trimTheorem2)
+	makeMapFoldingNumba, makeTheorem2, numbaOnTheorem2, trimTheorem2)
 from mapFolding.someAssemblyRequired.makingModules_doTheNeedful import makeInitializeState, makeUnRePackDataclass
 from mapFolding.someAssemblyRequired.toolkitMakeModules import getLogicalPath, getModule, getPathFilename
 from mapFolding.someAssemblyRequired.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight
@@ -196,7 +196,7 @@ def makeDaoOfMapFoldingParallelNumba(astModule: ast.Module, moduleIdentifier: st
 def makeMapFoldingModules() -> None:
 	"""Make multidimensional map folding modules."""
 	astModule = getModule(logicalPathInfix='algorithms')
-	pathFilename: PurePath = makeDaoOfMapFoldingNumba(astModule, 'daoOfMapFoldingNumba', None, logicalPathInfixDEFAULT, identifierCallableSourceDispatcherDEFAULT)
+	pathFilename: PurePath = makeMapFoldingNumba(astModule, 'daoOfMapFoldingNumba', None, logicalPathInfixDEFAULT, identifierCallableSourceDispatcherDEFAULT)
 
 	astModule = getModule(logicalPathInfix='algorithms')
 	pathFilename = makeDaoOfMapFoldingParallelNumba(astModule, 'countParallelNumba', None, logicalPathInfixDEFAULT, identifierCallableSourceDispatcherDEFAULT)
@@ -205,7 +205,7 @@ def makeMapFoldingModules() -> None:
 	makeInitializeState(astModule, 'initializeState', 'transitionOnGroupsOfFolds', logicalPathInfixDEFAULT)
 
 	astModule = getModule(logicalPathInfix='algorithms')
-	pathFilename = makeTheorem2(astModule, 'theorem2', None, logicalPathInfixDEFAULT, None)
+	pathFilename = makeTheorem2(astModule, 'theorem2', None, logicalPathInfixDEFAULT, identifierCallableSourceDispatcherDEFAULT)
 
 	astModule = parsePathFilename2astModule(pathFilename)
 	pathFilename = trimTheorem2(astModule, 'theorem2Trimmed', None, logicalPathInfixDEFAULT, None)