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

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 | 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.
+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 | str | 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 | str | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
-	"""Generate Numba-accelerated Theorem 2 implementation with dataclass decomposition.
+		dotModule: identifierDotAttribute = getLogicalPath(packageSettings.identifierPackage, logicalPathInfix, identifierModuleInitializeDataclass)
+		ingredientsFunctionDispatcher.imports.addImportFrom_asStr(dotModule, identifierCallableInitializeDataclass)
+
+		ingredientsModule.appendIngredientsFunction(ingredientsFunctionDispatcher)
+
+	pathFilename: PurePath = getPathFilename(packageSettings.pathPackage, logicalPathInfix, identifierModule)
 
-	(AI generated docstring)
+	write_astModule(ingredientsModule, pathFilename, packageSettings.identifierPackage)
 
-	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.
+	return pathFilename
 
-	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.
+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,54 +205,55 @@ 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)
-
-	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)
+	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 | str | 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.
@@ -278,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 | str | 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,8 +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
@@ -74,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
 
@@ -116,5 +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)

mapFolding/someAssemblyRequired/meanders/makeMeandersModules.py

@@ -0,0 +1,63 @@
+"""makeMeandersModules."""
+from astToolkit import (
+	astModuleToIngredientsFunction, Be, Grab, identifierDotAttribute, Make, NodeChanger, NodeTourist, Then)
+from hunterMakesPy import raiseIfNone
+from mapFolding import packageSettings
+from mapFolding.someAssemblyRequired import (
+	identifierCallableSourceDEFAULT, identifierCallableSourceDispatcherDEFAULT, IfThis, logicalPathInfixDEFAULT)
+from mapFolding.someAssemblyRequired.toolkitMakeModules import (
+	findDataclass, getModule, getPathFilename, write_astModule)
+from pathlib import PurePath
+import ast
+
+identifierDataclassNumPyHARDCODED = 'MatrixMeandersNumPyState'
+
+logicalPathInfixMeanders: str = logicalPathInfixDEFAULT + '.meanders'
+
+def makeCountBigInt(astModule: ast.Module, identifierModule: str, callableIdentifier: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, sourceCallableDispatcher: str | None = None) -> PurePath:
+	"""Make `countBigInt` module for meanders using `MatrixMeandersNumPyState` dataclass."""
+	identifierDataclassNumPy: str = identifierDataclassNumPyHARDCODED
+	_logicalPathDataclass, identifierDataclassOld, identifierDataclassInstance = findDataclass(astModuleToIngredientsFunction(astModule, raiseIfNone(sourceCallableDispatcher)))
+
+	NodeChanger(findThis=Be.FunctionDef.nameIs(IfThis.isIdentifier(identifierCallableSourceDEFAULT))
+		, doThat=Grab.nameAttribute(Then.replaceWith(raiseIfNone(callableIdentifier)))
+	).visit(astModule)
+
+	# Remove `doTheNeedful`
+	NodeChanger(Be.FunctionDef.nameIs(IfThis.isIdentifier(sourceCallableDispatcher)), Then.removeIt).visit(astModule)
+
+	# Change to `MatrixMeandersNumPyState`
+	NodeChanger(Be.Name.idIs(IfThis.isIdentifier(identifierDataclassOld))
+			, Grab.idAttribute(Then.replaceWith(identifierDataclassNumPy))
+		).visit(astModule)
+
+	NodeChanger(Be.alias.nameIs(IfThis.isIdentifier(identifierDataclassOld))
+			, Grab.nameAttribute(Then.replaceWith(identifierDataclassNumPy))
+		).visit(astModule)
+
+	# while (state.boundary > 0 and areIntegersWide(state)):  # noqa: ERA001
+	Call_areIntegersWide: ast.Call = Make.Call(Make.Name('areIntegersWide'), listParameters=[Make.Name('state')])
+	astCompare: ast.Compare = raiseIfNone(NodeTourist(
+		findThis=IfThis.isAttributeNamespaceIdentifierGreaterThan0(identifierDataclassInstance, 'boundary')
+		, doThat=Then.extractIt
+	).captureLastMatch(astModule))
+	newTest: ast.expr = Make.And.join([astCompare, Call_areIntegersWide])
+
+	NodeChanger(IfThis.isWhileAttributeNamespaceIdentifierGreaterThan0(identifierDataclassInstance, 'boundary')
+			, Grab.testAttribute(Then.replaceWith(newTest))
+	).visit(astModule)
+
+	# from mapFolding.algorithms.matrixMeandersBeDry import areIntegersWide  # noqa: ERA001
+	astModule.body.insert(0, Make.ImportFrom('mapFolding.algorithms.matrixMeandersBeDry', list_alias=[Make.alias('areIntegersWide')]))
+
+	pathFilename: PurePath = getPathFilename(logicalPathInfix=logicalPathInfix, identifierModule=identifierModule)
+
+	write_astModule(astModule, pathFilename, packageSettings.identifierPackage)
+
+	return pathFilename
+
+if __name__ == '__main__':
+	astModule: ast.Module = getModule(logicalPathInfix='algorithms', identifierModule='matrixMeanders')
+	pathFilename: PurePath = makeCountBigInt(astModule, 'bigInt', 'countBigInt', logicalPathInfixMeanders, identifierCallableSourceDispatcherDEFAULT)
+
+

mapFolding/someAssemblyRequired/toolkitMakeModules.py

@@ -42,16 +42,21 @@ from pathlib import PurePath
 from typing import Any
 import ast
 import io
+import isort
 
-def findDataclass(ingredientsFunction: IngredientsFunction) -> tuple[str, str, str]:
-	"""Extract dataclass information from a function's AST for transformation operations.
+def findDataclass(ingredientsFunction: IngredientsFunction) -> tuple[identifierDotAttribute, str, str]:
+	"""Dynamically extract information about a `dataclass`: the instance identifier, the identifier, and the logical path module.
 
-	(AI generated docstring)
+	Like many things in the "IngredientsFunction/IngredientsModule" ecosystem, this has specific requirements.
+	`ingredientsFunction` must have the dataclass as its first parameter. The `LedgerOfImports` in `ingredientsFunction` must have
+	the import information for the dataclass. If you are not using `IngredientsFunction`, you can still use this function to get
+	the information you want.
 
-	Analyzes the first parameter of a function to identify the dataclass type annotation
-	and instance identifier, then locates the module where the dataclass is defined by
-	examining the function's import statements. This information is essential for
-	dataclass decomposition and transformation operations.
+	```python
+	from astToolkit import astModuleToIngredientsFunction
+
+	tupleInformation = findDataclass(astModuleToIngredientsFunction(astAST, identifier))
+	```
 
 	Parameters
 	----------
@@ -60,58 +65,52 @@ def findDataclass(ingredientsFunction: IngredientsFunction) -> tuple[str, str, s
 
 	Returns
 	-------
-	dataclassLogicalPathModule : str
-		Module logical path where the dataclass is defined.
-	dataclassIdentifier : str
-		Class name of the dataclass.
-	dataclassInstanceIdentifier : str
-		Parameter name for the dataclass instance.
-
-	Raises
-	------
-	ValueError
-		If dataclass information cannot be extracted from the function.
-
+	logicalPathDataclass : identifierDotAttribute
+		Logical path from which the `dataclass` is imported, which might not be the real source of the `dataclass`.
+	identifierDataclass : str
+		Identifier of the `dataclass`.
+	identifierDataclassInstance : str
+		Identifier of the `dataclass` instance.
 	"""
 	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
+	identifierDataclass: str = raiseIfNone(NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName))
+	logicalPathDataclass = None
 	for moduleWithLogicalPath, listNameTuples in ingredientsFunction.imports._dictionaryImportFrom.items():  # noqa: SLF001
 		for nameTuple in listNameTuples:
-			if nameTuple[0] == dataclassIdentifier:
-				dataclassLogicalPathModule = moduleWithLogicalPath
+			if nameTuple[0] == identifierDataclass:
+				logicalPathDataclass = moduleWithLogicalPath
 				break
-		if dataclassLogicalPathModule:
+		if logicalPathDataclass:
 			break
-	dataclassInstanceIdentifier: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
-	return raiseIfNone(dataclassLogicalPathModule), dataclassIdentifier, dataclassInstanceIdentifier
+	identifierDataclassInstance: identifierDotAttribute = raiseIfNone(NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef))
+	return raiseIfNone(logicalPathDataclass), identifierDataclass, identifierDataclassInstance
 
-def getLogicalPath(identifierPackage: str | None = None, logicalPathInfix: str | None = None, *moduleIdentifier: str | None) -> identifierDotAttribute:
+def getLogicalPath(identifierPackage: str | None = None, logicalPathInfix: identifierDotAttribute | None = None, *identifierModule: str | None) -> identifierDotAttribute:
 	"""Get logical path from components."""
 	listLogicalPathParts: list[str] = []
 	if identifierPackage:
 		listLogicalPathParts.append(identifierPackage)
 	if logicalPathInfix:
 		listLogicalPathParts.append(logicalPathInfix)
-	if moduleIdentifier:
-		listLogicalPathParts.extend([module for module in moduleIdentifier if module is not None])
+	if identifierModule:
+		listLogicalPathParts.extend([module for module in identifierModule if module is not None])
 	return '.'.join(listLogicalPathParts)
 
-def getModule(identifierPackage: str | None = packageSettings.identifierPackage, logicalPathInfix: str | None = logicalPathInfixDEFAULT, moduleIdentifier: str | None = identifierModuleSourceAlgorithmDEFAULT) -> ast.Module:
+def getModule(identifierPackage: str | None = packageSettings.identifierPackage, logicalPathInfix: identifierDotAttribute | None = logicalPathInfixDEFAULT, identifierModule: str | None = identifierModuleSourceAlgorithmDEFAULT) -> ast.Module:
 	"""Get Module."""
-	logicalPathSourceModule: identifierDotAttribute = getLogicalPath(identifierPackage, logicalPathInfix, moduleIdentifier)
+	logicalPathSourceModule: identifierDotAttribute = getLogicalPath(identifierPackage, logicalPathInfix, identifierModule)
 	astModule: ast.Module = parseLogicalPath2astModule(logicalPathSourceModule)
 	return astModule
 
-def getPathFilename(pathRoot: PathLike[str] | PurePath | None = packageSettings.pathPackage, logicalPathInfix: PathLike[str] | PurePath | str | None = None, moduleIdentifier: str = '', fileExtension: str = packageSettings.fileExtension) -> PurePath:
+def getPathFilename(pathRoot: PathLike[str] | PurePath | None = packageSettings.pathPackage, logicalPathInfix: identifierDotAttribute | None = None, identifierModule: str = '', fileExtension: str = packageSettings.fileExtension) -> PurePath:
 	"""Construct filesystem path from logical path.
 
 	Parameters
 	----------
 	pathRoot : PathLike[str] | PurePath | None = packageSettings.pathPackage
 		Base directory for the package structure.
-	logicalPathInfix : PathLike[str] | PurePath | str | None = None
-		Subdirectory for organizing generated modules.
+	logicalPathInfix : identifierDotAttribute | None = None
+		Logical path in dot notation.
 	moduleIdentifier : str = ''
 		Name of the specific module file.
 	fileExtension : str = packageSettings.fileExtension
@@ -123,7 +122,7 @@ def getPathFilename(pathRoot: PathLike[str] | PurePath | None = packageSettings.
 		Complete filesystem path for the generated module file.
 
 	"""
-	pathFilename = PurePath(moduleIdentifier + fileExtension)
+	pathFilename = PurePath(identifierModule + fileExtension)
 	if logicalPathInfix:
 		pathFilename = PurePath(*(str(logicalPathInfix).split('.')), pathFilename)
 	if pathRoot:
@@ -131,7 +130,7 @@ def getPathFilename(pathRoot: PathLike[str] | PurePath | None = packageSettings.
 	return pathFilename
 
 def write_astModule(astModule: ast.Module, pathFilename: PathLike[Any] | PurePath | io.TextIOBase, packageName: str | None = None) -> None:
-	"""Prototype.
+	"""Prototype that will likely be moved to astToolkit.
 
 	Parameters
 	----------
@@ -148,5 +147,6 @@ def write_astModule(astModule: ast.Module, pathFilename: PathLike[Any] | PurePat
 	if packageName:
 		autoflake_additional_imports.append(packageName)
 	pythonSource = autoflake_fix_code(pythonSource, autoflake_additional_imports, expand_star_imports=False, remove_all_unused_imports=True, remove_duplicate_keys = False, remove_unused_variables = False)
-	writeStringToHere(pythonSource, pathFilename)
+	pythonSource = isort.code(pythonSource)
+	writeStringToHere(pythonSource + '\n', pathFilename)
 

mapFolding/someAssemblyRequired/transformationTools.py

@@ -34,7 +34,7 @@ from mapFolding.someAssemblyRequired import DeReConstructField2ast, IfThis, Shat
 import ast
 import dataclasses
 
-def shatter_dataclassesDOTdataclass(logicalPathModule: identifierDotAttribute, dataclassIdentifier: str, instanceIdentifier: str) -> ShatteredDataclass:
+def shatter_dataclassesDOTdataclass(logicalPathDataclass: identifierDotAttribute, identifierDataclass: str, identifierDataclassInstance: str) -> ShatteredDataclass:
 	"""Decompose a dataclass definition into AST components for manipulation and code generation.
 
 	(AI generated docstring)
@@ -77,19 +77,19 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: identifierDotAttribute, d
 	Official_fieldOrder: list[str] = []
 	dictionaryDeReConstruction: dict[str, DeReConstructField2ast] = {}
 
-	dataclassClassDef: ast.ClassDef | None = extractClassDef(parseLogicalPath2astModule(logicalPathModule), dataclassIdentifier)
+	dataclassClassDef: ast.ClassDef | None = extractClassDef(parseLogicalPath2astModule(logicalPathDataclass), identifierDataclass)
 	if not dataclassClassDef:
-		message = f"I could not find `{dataclassIdentifier = }` in `{logicalPathModule = }`."
+		message = f"I could not find `{identifierDataclass = }` in `{logicalPathDataclass = }`."
 		raise ValueError(message)
 
 	countingVariable = None
-	for aField in dataclasses.fields(importLogicalPath2Identifier(logicalPathModule, dataclassIdentifier)): # pyright: ignore [reportArgumentType]
+	for aField in dataclasses.fields(importLogicalPath2Identifier(logicalPathDataclass, identifierDataclass)): # pyright: ignore [reportArgumentType]
 		Official_fieldOrder.append(aField.name)
-		dictionaryDeReConstruction[aField.name] = DeReConstructField2ast(logicalPathModule, dataclassClassDef, instanceIdentifier, aField)
+		dictionaryDeReConstruction[aField.name] = DeReConstructField2ast(logicalPathDataclass, dataclassClassDef, identifierDataclassInstance, aField)
 		if aField.metadata.get('theCountingIdentifier', False):
 			countingVariable = dictionaryDeReConstruction[aField.name].name
 	if countingVariable is None:
-		message = f"I could not find the counting variable in `{dataclassIdentifier = }` in `{logicalPathModule = }`."
+		message = f"I could not find the counting variable in `{identifierDataclass = }` in `{logicalPathDataclass = }`."
 		raise ValueError(message)
 
 	shatteredDataclass = ShatteredDataclass(
@@ -105,11 +105,11 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: identifierDotAttribute, d
 		map_stateDOTfield2Name={dictionaryDeReConstruction[field].ast_nameDOTname: dictionaryDeReConstruction[field].astName for field in Official_fieldOrder},
 		)
 	shatteredDataclass.fragments4AssignmentOrParameters = Make.Tuple(shatteredDataclass.listName4Parameters, ast.Store())
-	shatteredDataclass.repack = Make.Assign([Make.Name(instanceIdentifier)], value=Make.Call(Make.Name(dataclassIdentifier), list_keyword=shatteredDataclass.list_keyword_field__field4init))
+	shatteredDataclass.repack = Make.Assign([Make.Name(identifierDataclassInstance)], value=Make.Call(Make.Name(identifierDataclass), list_keyword=shatteredDataclass.list_keyword_field__field4init))
 	shatteredDataclass.signatureReturnAnnotation = Make.Subscript(Make.Name('tuple'), Make.Tuple(shatteredDataclass.listAnnotations))
 
 	shatteredDataclass.imports.update(*(dictionaryDeReConstruction[field].ledger for field in Official_fieldOrder))
-	shatteredDataclass.imports.addImportFrom_asStr(logicalPathModule, dataclassIdentifier)
+	shatteredDataclass.imports.addImportFrom_asStr(logicalPathDataclass, identifierDataclass)
 
 	return shatteredDataclass