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

mapFolding/someAssemblyRequired/makingModules_count.py

@@ -0,0 +1,294 @@
+"""Make the `count` function for an algorithm.
+
+These transformation functions will work on at least two different algorithms. If a transformation function only works on a
+specific type of algorithm, it will be in a subdirectory.
+"""
+from astToolkit import (
+	astModuleToIngredientsFunction, Be, DOT, Grab, identifierDotAttribute, IngredientsFunction, IngredientsModule,
+	LedgerOfImports, Make, NodeChanger, NodeTourist, Then)
+from astToolkit.transformationTools import inlineFunctionDef, removeUnusedParameters, write_astModule
+from 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.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight
+from mapFolding.someAssemblyRequired.transformationTools import (
+	removeDataclassFromFunction, shatter_dataclassesDOTdataclass, unpackDataclassCallFunctionRepackDataclass)
+from os import PathLike
+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.
+
+	Parameters
+	----------
+	astModule : ast.Module
+		Source module containing the base algorithm.
+	moduleIdentifier : str
+		Name for the generated optimized module.
+	callableIdentifier : str | None = None
+		Name for the main computational function.
+	logicalPathInfix : PathLike[str] | PurePath | str | None = None
+		Directory path for organizing the generated module.
+	sourceCallableDispatcher : str | None = None
+		Optional dispatcher function for dataclass integration.
+
+	Returns
+	-------
+	pathFilename : PurePath
+		Filesystem path where the optimized module was written.
+
+	"""
+	sourceCallableIdentifier: identifierDotAttribute = identifierCallableSourceDEFAULT
+	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
+	ingredientsFunction.astFunctionDef.name = callableIdentifier or sourceCallableIdentifier
+
+	shatteredDataclass: ShatteredDataclass = shatter_dataclassesDOTdataclass(*findDataclass(ingredientsFunction))
+
+	ingredientsFunction.imports.update(shatteredDataclass.imports)
+	ingredientsFunction: IngredientsFunction = removeDataclassFromFunction(ingredientsFunction, shatteredDataclass)
+	ingredientsFunction = removeUnusedParameters(ingredientsFunction)
+	ingredientsFunction = decorateCallableWithNumba(ingredientsFunction, parametersNumbaLight)
+
+	ingredientsModule = IngredientsModule(ingredientsFunction)
+
+	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, moduleIdentifier)
+
+	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:
+	"""Generate module by applying optimization predicted by Theorem 2.
+
+	Parameters
+	----------
+	astModule : ast.Module
+		Source module containing the base algorithm.
+	moduleIdentifier : str
+		Name for the generated theorem-optimized module.
+	callableIdentifier : 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.
+
+	Returns
+	-------
+	pathFilename : PurePath
+		Filesystem path where the theorem-optimized module was written.
+
+	Raises
+	------
+	NotImplementedError
+		If `sourceCallableDispatcher` is provided.
+
+	"""
+	sourceCallableIdentifier = identifierCallableSourceDEFAULT
+	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
+	ingredientsFunction.astFunctionDef.name = callableIdentifier or sourceCallableIdentifier
+
+	dataclassInstanceIdentifier: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
+
+	theCountingIdentifier: identifierDotAttribute = identifierCountingDEFAULT
+	doubleTheCount: ast.AugAssign = Make.AugAssign(Make.Attribute(Make.Name(dataclassInstanceIdentifier), theCountingIdentifier), Make.Mult(), Make.Constant(2))
+
+	NodeChanger(
+		findThis = IfThis.isAllOf(
+			IfThis.isWhileAttributeNamespaceIdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+			, Be.While.orelseIs(lambda ImaList: ImaList))
+		, doThat = Grab.orelseAttribute(Grab.index(0, Then.insertThisBelow([doubleTheCount])))
+	).visit(ingredientsFunction.astFunctionDef)
+
+	NodeChanger(
+		findThis = IfThis.isAllOf(
+			IfThis.isWhileAttributeNamespaceIdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+			, Be.While.orelseIs(lambda ImaList: not ImaList))
+		, doThat = Grab.orelseAttribute(Then.replaceWith([doubleTheCount]))
+	).visit(ingredientsFunction.astFunctionDef)
+
+	NodeChanger(
+		findThis = IfThis.isWhileAttributeNamespaceIdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+		, doThat = Grab.testAttribute(Grab.comparatorsAttribute(Then.replaceWith([Make.Constant(4)])))
+	).visit(ingredientsFunction.astFunctionDef)
+
+	insertLeaf = NodeTourist(
+		findThis = IfThis.isIfAttributeNamespaceIdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+		, doThat = Then.extractIt(DOT.body)
+	).captureLastMatch(ingredientsFunction.astFunctionDef)
+	NodeChanger(
+		findThis = IfThis.isIfAttributeNamespaceIdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+		, doThat = Then.replaceWith(insertLeaf)
+	).visit(ingredientsFunction.astFunctionDef)
+
+	NodeChanger(
+		findThis = IfThis.isAttributeNamespaceIdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+		, doThat = Then.removeIt
+	).visit(ingredientsFunction.astFunctionDef)
+
+	NodeChanger(
+		findThis = IfThis.isAttributeNamespaceIdentifierLessThanOrEqual0(dataclassInstanceIdentifier, 'leaf1ndex')
+		, doThat = Then.removeIt
+	).visit(ingredientsFunction.astFunctionDef)
+
+	ingredientsModule = IngredientsModule(ingredientsFunction)
+
+	if sourceCallableDispatcher is not None:
+		message = 'sourceCallableDispatcher is not implemented yet'
+		raise NotImplementedError(message)
+
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
+
+	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
+
+	return pathFilename
+
+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.
+
+	(AI generated docstring)
+
+	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.
+
+	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.
+
+	Parameters
+	----------
+	astModule : ast.Module
+		Source module containing the Theorem 2 implementation.
+	moduleIdentifier : str
+		Name for the generated Numba-accelerated module.
+	callableIdentifier : str | None = None
+		Name for the accelerated computational function.
+	logicalPathInfix : PathLike[str] | PurePath | str | None = None
+		Directory path for organizing the generated module.
+	sourceCallableDispatcher : str | None = None
+		Optional dispatcher function identifier (unused).
+
+	Returns
+	-------
+	pathFilename : PurePath
+		Filesystem path where the accelerated module was written.
+
+	"""
+	sourceCallableIdentifier = identifierCallableSourceDEFAULT
+	if callableIdentifier is None:
+		callableIdentifier = sourceCallableIdentifier
+	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
+	ingredientsFunction.astFunctionDef.name = callableIdentifier
+
+	shatteredDataclass: ShatteredDataclass = shatter_dataclassesDOTdataclass(*findDataclass(ingredientsFunction))
+
+	ingredientsFunction.imports.update(shatteredDataclass.imports)
+	ingredientsFunction: IngredientsFunction = removeDataclassFromFunction(ingredientsFunction, shatteredDataclass)
+	ingredientsFunction = removeUnusedParameters(ingredientsFunction)
+	ingredientsFunction = decorateCallableWithNumba(ingredientsFunction, parametersNumbaLight)
+
+	ingredientsModule = IngredientsModule(ingredientsFunction)
+	ingredientsModule.removeImportFromModule('numpy')
+
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
+
+	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
+	"""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
+		Name for the generated trimmed module.
+	callableIdentifier : str | None = None
+		Name for the trimmed computational function.
+	logicalPathInfix : PathLike[str] | PurePath | str | None = None
+		Directory path for organizing the generated module.
+	sourceCallableDispatcher : str | None = None
+		Optional dispatcher function identifier (unused).
+
+	Returns
+	-------
+	pathFilename : PurePath
+		Filesystem path where the trimmed module was written.
+
+	"""
+	sourceCallableIdentifier = identifierCallableSourceDEFAULT
+	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
+	ingredientsFunction.astFunctionDef.name = callableIdentifier or sourceCallableIdentifier
+
+	dataclassInstanceIdentifier: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
+
+	findThis = IfThis.isIfUnaryNotAttributeNamespaceIdentifier(dataclassInstanceIdentifier, 'dimensionsUnconstrained')
+	doThat = Then.removeIt
+	NodeChanger(findThis, doThat).visit(ingredientsFunction.astFunctionDef)
+
+	ingredientsModule = IngredientsModule(ingredientsFunction)
+	ingredientsModule.removeImportFromModule('numpy')
+
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
+
+	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
+
+	return pathFilename
+
+
+

mapFolding/someAssemblyRequired/makingModules_doTheNeedful.py

@@ -0,0 +1,117 @@
+"""Make functions that are complementary to the `count` function and are often called by `doTheNeedful`."""
+from astToolkit import (
+	astModuleToIngredientsFunction, Be, DOT, extractFunctionDef, Grab, identifierDotAttribute, IngredientsFunction,
+	IngredientsModule, LedgerOfImports, Make, NodeChanger, NodeTourist, parseLogicalPath2astModule, Then)
+from astToolkit.transformationTools import inlineFunctionDef, write_astModule
+from hunterMakesPy import raiseIfNone
+from mapFolding import packageSettings
+from mapFolding.someAssemblyRequired import (
+	identifierCallableSourceDEFAULT, identifierCallableSourceDispatcherDEFAULT, identifierCountingDEFAULT,
+	identifierModuleDataPackingDEFAULT, identifierModuleSourceAlgorithmDEFAULT, IfThis, logicalPathInfixAlgorithmDEFAULT,
+	logicalPathInfixDEFAULT, ShatteredDataclass)
+from mapFolding.someAssemblyRequired.toolkitMakeModules import findDataclass, getPathFilename
+from mapFolding.someAssemblyRequired.transformationTools import (
+	shatter_dataclassesDOTdataclass, unpackDataclassCallFunctionRepackDataclass)
+from os import PathLike
+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
+	"""Generate initialization module for counting variable setup.
+
+	(AI generated docstring)
+
+	Creates a specialized module containing initialization logic for the counting variables
+	used in map folding computations. The generated function transforms the original
+	algorithm's loop conditions to use equality comparisons instead of greater-than
+	comparisons, optimizing the initialization phase.
+
+	This transformation is particularly important for ensuring that counting variables
+	are properly initialized before the main computational loops begin executing.
+
+	Parameters
+	----------
+	astModule : ast.Module
+		Source module containing the base algorithm.
+	moduleIdentifier : str
+		Name for the generated initialization module.
+	callableIdentifier : str | None = None
+		Name for the initialization function.
+	logicalPathInfix : PathLike[str] | PurePath | str | None = None
+		Directory path for organizing the generated module.
+	sourceCallableDispatcher : str | None = None
+		Optional dispatcher function identifier.
+
+	Returns
+	-------
+	pathFilename : PurePath
+		Filesystem path where the initialization module was written.
+
+	"""
+	sourceCallableIdentifier: identifierDotAttribute = identifierCallableSourceDEFAULT
+	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
+	ingredientsFunction.astFunctionDef.name = callableIdentifier or sourceCallableIdentifier
+
+	dataclassInstanceIdentifier: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
+	theCountingIdentifier: identifierDotAttribute = identifierCountingDEFAULT
+
+	findThis = IfThis.isWhileAttributeNamespaceIdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	doThat = Grab.testAttribute(Grab.andDoAllOf([Grab.opsAttribute(Then.replaceWith([ast.Eq()])), Grab.leftAttribute(Grab.attrAttribute(Then.replaceWith(theCountingIdentifier)))]))
+	NodeChanger(findThis, doThat).visit(ingredientsFunction.astFunctionDef.body[0])
+
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
+	write_astModule(IngredientsModule(ingredientsFunction), pathFilename, packageSettings.identifierPackage)
+
+	return pathFilename
+
+def makeUnRePackDataclass(astImportFrom: ast.ImportFrom, moduleIdentifier: str = identifierModuleDataPackingDEFAULT) -> None:
+	"""Generate interface module for dataclass unpacking and repacking operations.
+
+	Parameters
+	----------
+	astImportFrom : ast.ImportFrom
+		Import statement specifying the target optimized function to call.
+
+	Returns
+	-------
+	None
+		The generated module is written directly to the filesystem.
+
+	"""
+	callableIdentifierHARDCODED: str = 'sequential'
+
+	algorithmSourceModule: identifierDotAttribute = identifierModuleSourceAlgorithmDEFAULT
+	callableIdentifier: identifierDotAttribute = callableIdentifierHARDCODED
+	logicalPathInfix: identifierDotAttribute = logicalPathInfixDEFAULT
+	logicalPathInfixAlgorithm: identifierDotAttribute = logicalPathInfixAlgorithmDEFAULT
+	sourceCallableIdentifier: identifierDotAttribute = identifierCallableSourceDispatcherDEFAULT
+
+	logicalPathSourceModule: identifierDotAttribute = '.'.join([packageSettings.identifierPackage, logicalPathInfixAlgorithm, algorithmSourceModule])  # noqa: FLY002
+
+	ingredientsFunction: IngredientsFunction = astModuleToIngredientsFunction(parseLogicalPath2astModule(logicalPathSourceModule), sourceCallableIdentifier)
+	ingredientsFunction.astFunctionDef.name = callableIdentifier
+
+	shatteredDataclass: ShatteredDataclass = shatter_dataclassesDOTdataclass(*findDataclass(ingredientsFunction))
+
+	ingredientsFunction.imports.update(shatteredDataclass.imports)
+	ingredientsFunction.imports.addAst(astImportFrom)
+	targetCallableIdentifier: str = astImportFrom.names[0].name
+	ingredientsFunction = raiseIfNone(unpackDataclassCallFunctionRepackDataclass(ingredientsFunction, targetCallableIdentifier, shatteredDataclass))
+	targetFunctionDef: ast.FunctionDef = raiseIfNone(extractFunctionDef(parseLogicalPath2astModule(raiseIfNone(astImportFrom.module)), targetCallableIdentifier))
+	astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist(Be.Return.valueIs(Be.Tuple)
+			, doThat=Then.extractIt(DOT.value)).captureLastMatch(targetFunctionDef)))
+	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(ingredientsFunction.astFunctionDef)
+
+	ingredientsModule = IngredientsModule(ingredientsFunction)
+	ingredientsModule.removeImportFromModule('numpy')
+
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
+
+	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
+

mapFolding/someAssemblyRequired/mapFolding/makeMapFoldingModules.py

@@ -0,0 +1,220 @@
+"""makeMapFoldingModules."""
+from astToolkit import (
+	astModuleToIngredientsFunction, Be, DOT, extractClassDef, Grab, hasDOTbody, identifierDotAttribute,
+	IngredientsFunction, IngredientsModule, LedgerOfImports, Make, NodeChanger, NodeTourist, parseLogicalPath2astModule,
+	parsePathFilename2astModule, Then)
+from astToolkit.transformationTools import inlineFunctionDef, removeUnusedParameters, write_astModule
+from hunterMakesPy import importLogicalPath2Identifier, raiseIfNone
+from mapFolding import packageSettings
+from mapFolding.someAssemblyRequired import (
+	DeReConstructField2ast, identifierCallableSourceDEFAULT, identifierCallableSourceDispatcherDEFAULT, IfThis,
+	logicalPathInfixDEFAULT, ShatteredDataclass)
+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
+from mapFolding.someAssemblyRequired.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight
+from mapFolding.someAssemblyRequired.transformationTools import (
+	removeDataclassFromFunction, shatter_dataclassesDOTdataclass, unpackDataclassCallFunctionRepackDataclass)
+from os import PathLike
+from pathlib import PurePath
+from typing import Any, TYPE_CHECKING
+import ast
+import dataclasses
+
+if TYPE_CHECKING:
+	from collections.abc import Sequence
+
+def makeDaoOfMapFoldingParallelNumba(astModule: ast.Module, moduleIdentifier: str, callableIdentifier: str | None = None, logicalPathInfix: PathLike[str] | PurePath | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:  # noqa: ARG001
+	"""Generate parallel implementation with concurrent execution and task division.
+
+	Parameters
+	----------
+	astModule : ast.Module
+		Source module containing the base algorithm.
+	moduleIdentifier : str
+		Name for the generated parallel module.
+	callableIdentifier : str | None = None
+		Name for the core parallel counting function.
+	logicalPathInfix : PathLike[str] | PurePath | str | None = None
+		Directory path for organizing the generated module.
+	sourceCallableDispatcher : str | None = None
+		Optional dispatcher function identifier.
+
+	Returns
+	-------
+	pathFilename : PurePath
+		Filesystem path where the parallel module was written.
+
+	"""
+	sourceCallableIdentifier = identifierCallableSourceDEFAULT
+	if callableIdentifier is None:
+		callableIdentifier = sourceCallableIdentifier
+	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
+	ingredientsFunction.astFunctionDef.name = callableIdentifier
+
+	dataclassName: ast.expr = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(ingredientsFunction.astFunctionDef))
+	dataclassIdentifier: str = raiseIfNone(NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName))
+
+	dataclassLogicalPathModule = None
+	for moduleWithLogicalPath, listNameTuples in ingredientsFunction.imports._dictionaryImportFrom.items():  # noqa: SLF001
+		for nameTuple in listNameTuples:
+			if nameTuple[0] == dataclassIdentifier:
+				dataclassLogicalPathModule = moduleWithLogicalPath
+				break
+		if dataclassLogicalPathModule:
+			break
+	if dataclassLogicalPathModule is None:
+		raise Exception  # noqa: TRY002
+	dataclassInstanceIdentifier: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
+	shatteredDataclass: ShatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclassIdentifier, dataclassInstanceIdentifier)
+
+	# START add the parallel state fields to the count function ------------------------------------------------
+	dataclassBaseFields: tuple[dataclasses.Field[Any], ...] = dataclasses.fields(importLogicalPath2Identifier(dataclassLogicalPathModule, dataclassIdentifier))  # pyright: ignore [reportArgumentType]
+	dataclassIdentifierParallel: identifierDotAttribute = 'Parallel' + dataclassIdentifier
+	dataclassFieldsParallel: tuple[dataclasses.Field[Any], ...] = dataclasses.fields(importLogicalPath2Identifier(dataclassLogicalPathModule, dataclassIdentifierParallel))  # pyright: ignore [reportArgumentType]
+	onlyParallelFields: list[dataclasses.Field[Any]] = [field for field in dataclassFieldsParallel if field.name not in [fieldBase.name for fieldBase in dataclassBaseFields]]
+
+	Official_fieldOrder: list[str] = []
+	dictionaryDeReConstruction: dict[str, DeReConstructField2ast] = {}
+
+	dataclassClassDef: ast.ClassDef | None = extractClassDef(parseLogicalPath2astModule(dataclassLogicalPathModule), dataclassIdentifierParallel)
+	if not dataclassClassDef:
+		message = f"I could not find `{dataclassIdentifierParallel = }` in `{dataclassLogicalPathModule = }`."
+		raise ValueError(message)
+
+	for aField in onlyParallelFields:
+		Official_fieldOrder.append(aField.name)
+		dictionaryDeReConstruction[aField.name] = DeReConstructField2ast(dataclassLogicalPathModule, dataclassClassDef, dataclassInstanceIdentifier, aField)
+
+	shatteredDataclassParallel = ShatteredDataclass(
+		countingVariableAnnotation=shatteredDataclass.countingVariableAnnotation,
+		countingVariableName=shatteredDataclass.countingVariableName,
+		field2AnnAssign={**shatteredDataclass.field2AnnAssign, **{dictionaryDeReConstruction[field].name: dictionaryDeReConstruction[field].astAnnAssignConstructor for field in Official_fieldOrder}},
+		Z0Z_field2AnnAssign={**shatteredDataclass.Z0Z_field2AnnAssign, **{dictionaryDeReConstruction[field].name: dictionaryDeReConstruction[field].Z0Z_hack for field in Official_fieldOrder}},
+		list_argAnnotated4ArgumentsSpecification=shatteredDataclass.list_argAnnotated4ArgumentsSpecification + [dictionaryDeReConstruction[field].ast_argAnnotated for field in Official_fieldOrder],
+		list_keyword_field__field4init=shatteredDataclass.list_keyword_field__field4init + [dictionaryDeReConstruction[field].ast_keyword_field__field for field in Official_fieldOrder if dictionaryDeReConstruction[field].init],
+		listAnnotations=shatteredDataclass.listAnnotations + [dictionaryDeReConstruction[field].astAnnotation for field in Official_fieldOrder],
+		listName4Parameters=shatteredDataclass.listName4Parameters + [dictionaryDeReConstruction[field].astName for field in Official_fieldOrder],
+		listUnpack=shatteredDataclass.listUnpack + [Make.AnnAssign(dictionaryDeReConstruction[field].astName, dictionaryDeReConstruction[field].astAnnotation, dictionaryDeReConstruction[field].ast_nameDOTname) for field in Official_fieldOrder],
+		map_stateDOTfield2Name={**shatteredDataclass.map_stateDOTfield2Name, **{dictionaryDeReConstruction[field].ast_nameDOTname: dictionaryDeReConstruction[field].astName for field in Official_fieldOrder}},
+		)
+	shatteredDataclassParallel.fragments4AssignmentOrParameters = Make.Tuple(shatteredDataclassParallel.listName4Parameters, Make.Store())
+	shatteredDataclassParallel.repack = Make.Assign([Make.Name(dataclassInstanceIdentifier)], value=Make.Call(Make.Name(dataclassIdentifierParallel), list_keyword=shatteredDataclassParallel.list_keyword_field__field4init))
+	shatteredDataclassParallel.signatureReturnAnnotation = Make.Subscript(Make.Name('tuple'), Make.Tuple(shatteredDataclassParallel.listAnnotations))
+
+	shatteredDataclassParallel.imports.update(*(dictionaryDeReConstruction[field].ledger for field in Official_fieldOrder))
+	shatteredDataclassParallel.imports.addImportFrom_asStr(dataclassLogicalPathModule, dataclassIdentifierParallel)
+	shatteredDataclassParallel.imports.update(shatteredDataclass.imports)
+	shatteredDataclassParallel.imports.removeImportFrom(dataclassLogicalPathModule, dataclassIdentifier)
+
+	# END add the parallel state fields to the count function ------------------------------------------------
+
+	ingredientsFunction.imports.update(shatteredDataclassParallel.imports)
+	ingredientsFunction: IngredientsFunction = removeDataclassFromFunction(ingredientsFunction, shatteredDataclassParallel)
+
+	# START add the parallel logic to the count function ------------------------------------------------
+
+	findThis = Be.While.testIs(Be.Compare.leftIs(IfThis.isNameIdentifier('leafConnectee')))
+	captureCountGapsCodeBlock: NodeTourist[ast.While, Sequence[ast.stmt]] = NodeTourist(findThis, doThat = Then.extractIt(DOT.body))
+	countGapsCodeBlock: Sequence[ast.stmt] = raiseIfNone(captureCountGapsCodeBlock.captureLastMatch(ingredientsFunction.astFunctionDef))
+
+	thisIsMyTaskIndexCodeBlock = ast.If(ast.BoolOp(ast.Or()
+		, values=[ast.Compare(ast.Name('leaf1ndex'), ops=[ast.NotEq()], comparators=[ast.Name('taskDivisions')])
+				, ast.Compare(Make.Mod.join([ast.Name('leafConnectee'), ast.Name('taskDivisions')]), ops=[ast.Eq()], comparators=[ast.Name('taskIndex')])])
+	, body=list(countGapsCodeBlock[0:-1]))
+
+	countGapsCodeBlockNew: list[ast.stmt] = [thisIsMyTaskIndexCodeBlock, countGapsCodeBlock[-1]]
+	NodeChanger[ast.While, hasDOTbody](findThis, doThat = Grab.bodyAttribute(Then.replaceWith(countGapsCodeBlockNew))).visit(ingredientsFunction.astFunctionDef)
+
+	# END add the parallel logic to the count function ------------------------------------------------
+
+	ingredientsFunction = removeUnusedParameters(ingredientsFunction)
+
+	ingredientsFunction = decorateCallableWithNumba(ingredientsFunction, parametersNumbaLight)
+
+	# START unpack/repack the dataclass function ------------------------------------------------
+	sourceCallableIdentifier = identifierCallableSourceDispatcherDEFAULT
+
+	unRepackDataclass: IngredientsFunction = astModuleToIngredientsFunction(astModule, sourceCallableIdentifier)
+	unRepackDataclass.astFunctionDef.name = 'unRepack' + dataclassIdentifierParallel
+	unRepackDataclass.imports.update(shatteredDataclassParallel.imports)
+	NodeChanger(
+			findThis = Be.arg.annotationIs(Be.Name.idIs(lambda thisAttribute: thisAttribute == dataclassIdentifier)) # pyright: ignore[reportArgumentType]
+			, doThat = Grab.annotationAttribute(Grab.idAttribute(Then.replaceWith(dataclassIdentifierParallel)))
+		).visit(unRepackDataclass.astFunctionDef)
+	unRepackDataclass.astFunctionDef.returns = Make.Name(dataclassIdentifierParallel)
+	targetCallableIdentifier: identifierDotAttribute = ingredientsFunction.astFunctionDef.name
+	unRepackDataclass = unpackDataclassCallFunctionRepackDataclass(unRepackDataclass, targetCallableIdentifier, shatteredDataclassParallel)
+
+	astTuple: ast.Tuple = raiseIfNone(NodeTourist[ast.Return, ast.Tuple](Be.Return, Then.extractIt(DOT.value)).captureLastMatch(ingredientsFunction.astFunctionDef)) # pyright: ignore[reportArgumentType]
+	astTuple.ctx = Make.Store()
+	changeAssignCallToTarget: NodeChanger[ast.Assign, ast.Assign] = NodeChanger(
+		findThis = Be.Assign.valueIs(IfThis.isCallIdentifier(targetCallableIdentifier))
+		, doThat = Then.replaceWith(Make.Assign([astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
+	)
+	changeAssignCallToTarget.visit(unRepackDataclass.astFunctionDef)
+
+	ingredientsDoTheNeedful: IngredientsFunction = IngredientsFunction(
+		astFunctionDef = Make.FunctionDef('doTheNeedful'
+			, argumentSpecification=Make.arguments(list_arg=[Make.arg('state', annotation=Make.Name(dataclassIdentifierParallel)), Make.arg('concurrencyLimit', annotation=Make.Name('int'))])
+			, body=[Make.Assign([Make.Name('stateParallel', Make.Store())], value=Make.Call(Make.Name('deepcopy'), listParameters=[Make.Name('state')]))
+				, Make.AnnAssign(Make.Name('listStatesParallel', Make.Store()), annotation=Make.Subscript(value=Make.Name('list'), slice=Make.Name(dataclassIdentifierParallel))
+					, value=Make.Mult.join([Make.List([Make.Name('stateParallel')]), Make.Attribute(Make.Name('stateParallel'), 'taskDivisions')]))
+				, Make.AnnAssign(Make.Name('groupsOfFoldsTotal', Make.Store()), annotation=Make.Name('int'), value=Make.Constant(value=0))
+
+				, Make.AnnAssign(Make.Name('dictionaryConcurrency', Make.Store()), annotation=Make.Subscript(value=Make.Name('dict'), slice=Make.Tuple([Make.Name('int'), Make.Subscript(value=Make.Name('ConcurrentFuture'), slice=Make.Name(dataclassIdentifierParallel))])), value=Make.Dict())
+				, Make.With(items=[Make.withitem(context_expr=Make.Call(Make.Name('ProcessPoolExecutor'), listParameters=[Make.Name('concurrencyLimit')]), optional_vars=Make.Name('concurrencyManager', Make.Store()))]
+					, body=[Make.For(Make.Name('indexSherpa', Make.Store()), iter=Make.Call(Make.Name('range'), listParameters=[Make.Attribute(Make.Name('stateParallel'), 'taskDivisions')])
+							, body=[Make.Assign([Make.Name('state', Make.Store())], value=Make.Call(Make.Name('deepcopy'), listParameters=[Make.Name('stateParallel')]))
+								, Make.Assign([Make.Attribute(Make.Name('state'), 'taskIndex', context=Make.Store())], value=Make.Name('indexSherpa'))
+								, Make.Assign([Make.Subscript(Make.Name('dictionaryConcurrency'), slice=Make.Name('indexSherpa'), context=Make.Store())], value=Make.Call(Make.Attribute(Make.Name('concurrencyManager'), 'submit'), listParameters=[Make.Name(unRepackDataclass.astFunctionDef.name), Make.Name('state')]))])
+						, Make.For(Make.Name('indexSherpa', Make.Store()), iter=Make.Call(Make.Name('range'), listParameters=[Make.Attribute(Make.Name('stateParallel'), 'taskDivisions')])
+							, body=[Make.Assign([Make.Subscript(Make.Name('listStatesParallel'), slice=Make.Name('indexSherpa'), context=Make.Store())], value=Make.Call(Make.Attribute(Make.Subscript(Make.Name('dictionaryConcurrency'), slice=Make.Name('indexSherpa')), 'result')))
+								, Make.AugAssign(Make.Name('groupsOfFoldsTotal', Make.Store()), op=ast.Add(), value=Make.Attribute(Make.Subscript(Make.Name('listStatesParallel'), slice=Make.Name('indexSherpa')), 'groupsOfFolds'))])])
+
+				, Make.AnnAssign(Make.Name('foldsTotal', Make.Store()), annotation=Make.Name('int'), value=Make.Mult.join([Make.Name('groupsOfFoldsTotal'), Make.Attribute(Make.Name('stateParallel'), 'leavesTotal')]))
+				, Make.Return(Make.Tuple([Make.Name('foldsTotal'), Make.Name('listStatesParallel')]))]
+			, returns=Make.Subscript(Make.Name('tuple'), slice=Make.Tuple([Make.Name('int'), Make.Subscript(Make.Name('list'), slice=Make.Name(dataclassIdentifierParallel))])))
+		, imports = LedgerOfImports(Make.Module([Make.ImportFrom('concurrent.futures', list_alias=[Make.alias('Future', asName='ConcurrentFuture'), Make.alias('ProcessPoolExecutor')]),
+			Make.ImportFrom('copy', list_alias=[Make.alias('deepcopy')]),
+			Make.ImportFrom('multiprocessing', list_alias=[Make.alias('set_start_method', asName='multiprocessing_set_start_method')])])
+		)
+	)
+
+	ingredientsModule = IngredientsModule([ingredientsFunction, unRepackDataclass, ingredientsDoTheNeedful]
+						, prologue = Make.Module([Make.If(test=Make.Compare(left=Make.Name('__name__'), ops=[Make.Eq()], comparators=[Make.Constant('__main__')]), body=[Make.Expr(Make.Call(Make.Name('multiprocessing_set_start_method'), listParameters=[Make.Constant('spawn')]))])])
+	)
+	ingredientsModule.removeImportFromModule('numpy')
+
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, moduleIdentifier)
+
+	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
+
+	return pathFilename
+
+def makeMapFoldingModules() -> None:
+	"""Make multidimensional map folding modules."""
+	astModule = getModule(logicalPathInfix='algorithms')
+	pathFilename: PurePath = makeDaoOfMapFoldingNumba(astModule, 'daoOfMapFoldingNumba', None, logicalPathInfixDEFAULT, identifierCallableSourceDispatcherDEFAULT)
+
+	astModule = getModule(logicalPathInfix='algorithms')
+	pathFilename = makeDaoOfMapFoldingParallelNumba(astModule, 'countParallelNumba', None, logicalPathInfixDEFAULT, identifierCallableSourceDispatcherDEFAULT)
+
+	astModule: ast.Module = getModule(logicalPathInfix='algorithms')
+	makeInitializeState(astModule, 'initializeState', 'transitionOnGroupsOfFolds', logicalPathInfixDEFAULT)
+
+	astModule = getModule(logicalPathInfix='algorithms')
+	pathFilename = makeTheorem2(astModule, 'theorem2', None, logicalPathInfixDEFAULT, None)
+
+	astModule = parsePathFilename2astModule(pathFilename)
+	pathFilename = trimTheorem2(astModule, 'theorem2Trimmed', None, logicalPathInfixDEFAULT, None)
+
+	astModule = parsePathFilename2astModule(pathFilename)
+	pathFilename = numbaOnTheorem2(astModule, 'theorem2Numba', None, logicalPathInfixDEFAULT, None)
+
+	astImportFrom: ast.ImportFrom = Make.ImportFrom(getLogicalPath(packageSettings.identifierPackage, logicalPathInfixDEFAULT, 'theorem2Numba'), list_alias=[Make.alias(identifierCallableSourceDEFAULT)])
+	makeUnRePackDataclass(astImportFrom)
+
+if __name__ == '__main__':
+	makeMapFoldingModules()