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

mapFolding/someAssemblyRequired/infoBooth.py

@@ -11,42 +11,39 @@ on empirical measurements and theoretical analysis of map folding algorithms for
 specific dimensional configurations.
 """
 
-algorithmSourceModuleDEFAULT: str = 'daoOfMapFolding'
-"""Default identifier for the algorithm source module containing the base implementation."""
-
-dataclassInstanceIdentifierDEFAULT: str = 'state'
-"""Default variable name for dataclass instances in generated code."""
-
-dataPackingModuleIdentifierDEFAULT: str = 'dataPacking'
-"""Default identifier for modules containing data packing and unpacking functions."""
-
-logicalPathInfixDEFAULT: str = 'syntheticModules'
-"""Default path component for organizing synthetic generated modules."""
-
-sourceCallableDispatcherDEFAULT: str = 'doTheNeedful'
-"""Default identifier for dispatcher functions that route computational tasks."""
-
-sourceCallableIdentifierDEFAULT: str = 'count'
-"""Default identifier for the core counting function in algorithms."""
+from hunterMakesPy import identifierDotAttribute
+from typing import Final
 
-theCountingIdentifierDEFAULT: str = 'groupsOfFolds'
-"""Default identifier for the primary counting variable in map folding computations."""
-
-dictionaryEstimates: dict[tuple[int, ...], int] = {
+dictionaryEstimatesMapFolding: Final[dict[tuple[int, ...], int]] = {
 	(2,2,2,2,2,2,2,2): 798148657152000,
 	(2,21): 776374224866624,
 	(3,15): 824761667826225,
 	(3,3,3,3): 85109616000000000000000000000000,
 	(8,8): 791274195985524900,
 }
-"""
-Registry of computational complexity estimates for specific map dimension configurations.
+"""Estimates of multidimensional map folding `foldsTotal`."""
 
-Maps dimensional tuples to estimated fold counts based on empirical measurements and
-theoretical analysis. These estimates guide optimization decisions and resource planning
-for computational tasks with known dimensional parameters.
+identifierCallableSourceDEFAULT: Final[str] = 'count'
+"""Default identifier for the core counting function in algorithms."""
+
+identifierCallableSourceDispatcherDEFAULT: Final[str] = 'doTheNeedful'
+"""Default identifier for dispatcher functions that route computational tasks."""
+
+identifierCountingDEFAULT: Final[str] = 'groupsOfFolds'
+"""Default identifier for the primary counting variable in map folding computations."""
+
+identifierDataclassInstanceDEFAULT: Final[str] = 'state'
+"""Default variable name for dataclass instances in generated code."""
+
+identifierModuleDataPackingDEFAULT: Final[str] = 'dataPacking'
+"""Default identifier for modules containing data packing and unpacking functions."""
+
+identifierModuleSourceAlgorithmDEFAULT: Final[str] = 'daoOfMapFolding'
+"""Default identifier for the algorithm source module containing the base implementation."""
+
+logicalPathInfixAlgorithmDEFAULT: Final[identifierDotAttribute] = 'algorithms'
+"""Default logical path component for handmade algorithms."""
+
+logicalPathInfixDEFAULT: Final[identifierDotAttribute] = 'syntheticModules'
+"""Default logical path component for organizing synthetic generated modules."""
 
-The estimates represent the expected number of computational operations or fold
-configurations for the given map dimensions, helping determine appropriate optimization
-strategies and computational resource allocation.
-"""

mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py

@@ -326,7 +326,7 @@ if __name__ == '__main__':
 	"""
 
 if __name__ == '__main__':
-	state = transitionOnGroupsOfFolds(MapFoldingState((2,4)))
+	state = transitionOnGroupsOfFolds(MapFoldingState((1,27)))
 	pathModule = PurePosixPath(packageSettings.pathPackage, 'jobs')
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
 	aJob = RecipeJobTheorem2(state, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)

mapFolding/someAssemblyRequired/makeJobTheorem2codon.py

@@ -100,7 +100,9 @@ def _variableCompatibility(ingredientsFunction: IngredientsFunction, job: Recipe
 		# `identifier` in Augmented Assignment, or in Assignments and value is Constant.
 		NodeChanger(findThis=IfThis.isAnyOf(
 				Be.AugAssign.targetIs(IfThis.isNestedNameIdentifier(identifier))
-				, IfThis.isAllOf(IfThis.isAssignAndTargets0Is(IfThis.isNameIdentifier(identifier))
+				, IfThis.isAllOf(
+					Be.Assign.targetsIs(Be.at(0, IfThis.isNestedNameIdentifier(identifier)))
+					# IfThis.isAssignAndTargets0Is(IfThis.isNameIdentifier(identifier))
 					, Be.Assign.valueIs(Be.Constant))
 			)
 			, doThat=lambda node, annotation=annotation: Grab.valueAttribute(Then.replaceWith(Make.Call(annotation, listParameters=[node.value])))(node)
@@ -113,6 +115,7 @@ def _variableCompatibility(ingredientsFunction: IngredientsFunction, job: Recipe
 
 		# `identifier` in Comparison.
 		NodeChanger(Be.Compare.leftIs(IfThis.isNestedNameIdentifier(identifier))
+			# , doThat=Grab.comparatorsAttribute(Grab.index(0, lambda comparator, annotation=annotation: Then.replaceWith(Make.Call(annotation, listParameters=[comparator]))))
 			, doThat=lambda node, annotation=annotation: Grab.comparatorsAttribute(lambda at, annotation=annotation: Then.replaceWith([Make.Call(annotation, listParameters=[node.comparators[0]])])(at[0]))(node)
 		).visit(ingredientsFunction.astFunctionDef)
 
@@ -220,6 +223,6 @@ def fromMapShape(mapShape: tuple[DatatypeLeavesTotal, ...]) -> None:
 	makeJob(aJob)
 
 if __name__ == '__main__':
-	mapShape = (1, 15)
+	mapShape = (1, 3)
 	fromMapShape(mapShape)
 

mapFolding/someAssemblyRequired/makingModules_count.py

@@ -0,0 +1,301 @@
+"""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 | str | 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 | str | 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 | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
+	"""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)
+
+	if sourceCallableDispatcher is not None:
+		NodeChanger(
+			findThis=IfThis.isCallIdentifier(sourceCallableDispatcher)
+			, doThat=Then.replaceWith(astExprCall_filterAsymmetricFoldsLeafBelow)
+			).visit(ingredientsFunction.astFunctionDef)
+
+	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 | str | 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,120 @@
+"""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 | str | 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)
+
+
+