mapFolding 0.11.1__py3-none-any.whl → 0.11.3__py3-none-any.whl

mapFolding/someAssemblyRequired/{_toolboxContainers.py → _toolkitContainers.py}

@@ -18,137 +18,18 @@ The containers work in conjunction with transformation tools that manipulate the
 specific optimizations and transformations.
 """
 
+from astToolkit import ast_Identifier, ClassIsAndAttribute, DOT, LedgerOfImports, Make, NodeTourist, str_nameDOTname, Then
 from collections.abc import Callable
 from copy import deepcopy
-from mapFolding.someAssemblyRequired import ast_Identifier, DOT, IfThis, Make, NodeTourist, parseLogicalPath2astModule, str_nameDOTname, Then, LedgerOfImports
-from mapFolding.theSSOT import raiseIfNoneGitHubIssueNumber3, The
-from pathlib import Path, PurePosixPath
+from mapFolding.someAssemblyRequired import IfThis, raiseIfNoneGitHubIssueNumber3
 from typing import Any, cast
 import ast
 import dataclasses
 
-# Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
-@dataclasses.dataclass
-class RecipeSynthesizeFlow:
-	"""
-	Configure the generation of new modules, including Numba-accelerated code modules.
-
-	RecipeSynthesizeFlow defines the complete blueprint for transforming an original Python algorithm into an optimized,
-	accelerated implementation. It specifies:
-
-	1. Source code locations and identifiers.
-	2. Target code locations and identifiers.
-	3. Naming conventions for generated modules and functions.
-	4. File system paths for output files.
-	5. Import relationships between components.
-
-	This configuration class serves as a single source of truth for the code generation process, ensuring consistency
-	across all generated artifacts while enabling customization of the transformation assembly line.
-
-	The transformation process uses this configuration to extract functions from the source module, transform them
-	according to optimization rules, and output properly structured optimized modules with all necessary imports.
-	"""
-	# ========================================
-	# Source
-	source_astModule: ast.Module = parseLogicalPath2astModule(The.logicalPathModuleSourceAlgorithm)
-	"""AST of the source algorithm module containing the original implementation."""
-
-	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-	sourceCallableDispatcher: ast_Identifier = The.sourceCallableDispatcher
-	sourceCallableInitialize: ast_Identifier = The.sourceCallableInitialize
-	sourceCallableParallel: ast_Identifier = The.sourceCallableParallel
-	sourceCallableSequential: ast_Identifier = The.sourceCallableSequential
-
-	sourceDataclassIdentifier: ast_Identifier = The.dataclassIdentifier
-	sourceDataclassInstance: ast_Identifier = The.dataclassInstance
-	sourceDataclassInstanceTaskDistribution: ast_Identifier = The.dataclassInstanceTaskDistribution
-	sourceLogicalPathModuleDataclass: str_nameDOTname = The.logicalPathModuleDataclass
-
-	sourceConcurrencyManagerNamespace = The.sourceConcurrencyManagerNamespace
-	sourceConcurrencyManagerIdentifier = The.sourceConcurrencyManagerIdentifier
-
-	# ========================================
-	# Logical identifiers (as opposed to physical identifiers)
-	# ========================================
-	# Package ================================
-	packageIdentifier: ast_Identifier | None = The.packageName
-
-	# Qualified logical path ================================
-	logicalPathModuleDataclass: str_nameDOTname = sourceLogicalPathModuleDataclass
-	logicalPathFlowRoot: ast_Identifier | None = 'syntheticModules'
-	""" `logicalPathFlowRoot` likely corresponds to a physical filesystem directory."""
-
-	# Module ================================
-	moduleDispatcher: ast_Identifier = 'numbaCount'
-	moduleInitialize: ast_Identifier = moduleDispatcher
-	moduleParallel: ast_Identifier = moduleDispatcher
-	moduleSequential: ast_Identifier = moduleDispatcher
-
-	# Function ================================
-	callableDispatcher: ast_Identifier = sourceCallableDispatcher
-	callableInitialize: ast_Identifier = sourceCallableInitialize
-	callableParallel: ast_Identifier = sourceCallableParallel
-	callableSequential: ast_Identifier = sourceCallableSequential
-	concurrencyManagerNamespace: ast_Identifier = sourceConcurrencyManagerNamespace
-	concurrencyManagerIdentifier: ast_Identifier = sourceConcurrencyManagerIdentifier
-	dataclassIdentifier: ast_Identifier = sourceDataclassIdentifier
-
-	# Variable ================================
-	dataclassInstance: ast_Identifier = sourceDataclassInstance
-	dataclassInstanceTaskDistribution: ast_Identifier = sourceDataclassInstanceTaskDistribution
-
-	removeDataclassDispatcher: bool = False
-	removeDataclassInitialize: bool = False
-	removeDataclassParallel: bool = True
-	removeDataclassSequential: bool = True
-	# ========================================
-	# Computed
-	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-	# theFormatStrModuleSynthetic = "{packageFlow}Count"
-	# theFormatStrModuleForCallableSynthetic = theFormatStrModuleSynthetic + "_{callableTarget}"
-	# theModuleDispatcherSynthetic: ast_Identifier = theFormatStrModuleForCallableSynthetic.format(packageFlow=packageFlowSynthetic, callableTarget=The.sourceCallableDispatcher)
-	# theLogicalPathModuleDispatcherSynthetic: str = '.'.join([The.packageName, The.moduleOfSyntheticModules, theModuleDispatcherSynthetic])
-	# logicalPathModuleDispatcher: str = '.'.join([Z0Z_flowLogicalPathRoot, moduleDispatcher])
-
-	# ========================================
-	# Filesystem (names of physical objects)
-	pathPackage: PurePosixPath | None = PurePosixPath(The.pathPackage)
-	fileExtension: str = The.fileExtension
-
-	def _makePathFilename(self, filenameStem: str,
-			pathRoot: PurePosixPath | None = None,
-			logicalPathINFIX: str_nameDOTname | None = None,
-			fileExtension: str | None = None,
-			) -> PurePosixPath:
-		"""filenameStem: (hint: the name of the logical module)"""
-		if pathRoot is None:
-			pathRoot = self.pathPackage or PurePosixPath(Path.cwd())
-		if logicalPathINFIX:
-			whyIsThisStillAThing: list[str] = logicalPathINFIX.split('.')
-			pathRoot = pathRoot.joinpath(*whyIsThisStillAThing)
-		if fileExtension is None:
-			fileExtension = self.fileExtension
-		filename: str = filenameStem + fileExtension
-		return pathRoot.joinpath(filename)
-
-	@property
-	def pathFilenameDispatcher(self) -> PurePosixPath:
-		return self._makePathFilename(filenameStem=self.moduleDispatcher, logicalPathINFIX=self.logicalPathFlowRoot)
-	@property
-	def pathFilenameInitialize(self) -> PurePosixPath:
-		return self._makePathFilename(filenameStem=self.moduleInitialize, logicalPathINFIX=self.logicalPathFlowRoot)
-	@property
-	def pathFilenameParallel(self) -> PurePosixPath:
-		return self._makePathFilename(filenameStem=self.moduleParallel, logicalPathINFIX=self.logicalPathFlowRoot)
-	@property
-	def pathFilenameSequential(self) -> PurePosixPath:
-		return self._makePathFilename(filenameStem=self.moduleSequential, logicalPathINFIX=self.logicalPathFlowRoot)
-
 dummyAssign = Make.Assign([Make.Name("dummyTarget")], Make.Constant(None))
 dummySubscript = Make.Subscript(Make.Name("dummy"), Make.Name("slice"))
 dummyTuple = Make.Tuple([Make.Name("dummyElement")])
 
-# Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
 @dataclasses.dataclass
 class ShatteredDataclass:
 	countingVariableAnnotation: ast.expr
@@ -252,14 +133,12 @@ class DeReConstructField2ast:
 		self.ast_keyword_field__field = Make.keyword(self.name, self.astName)
 		self.ast_nameDOTname = Make.Attribute(Make.Name(dataclassesDOTdataclassInstance_Identifier), self.name)
 
-		findThis = IfThis.isAnnAssign_targetIs(IfThis.isName_Identifier(self.name))
-
-		sherpa = NodeTourist(
-			findThis=findThis
-			, doThat=Then.extractIt(DOT.annotation)
+		sherpa: ast.expr = NodeTourist( # type: ignore
+			findThis=ClassIsAndAttribute.targetIs(ast.AnnAssign, IfThis.isName_Identifier(self.name))
+			, doThat=Then.extractIt(DOT.annotation) # type: ignore
 			).captureLastMatch(dataclassClassDef)
 
-		if sherpa is None: raise raiseIfNoneGitHubIssueNumber3
+		if sherpa is None: raise raiseIfNoneGitHubIssueNumber3 # type: ignore
 		else: self.astAnnotation = sherpa
 
 		self.ast_argAnnotated = Make.arg(self.name, self.astAnnotation)

mapFolding/someAssemblyRequired/infoBooth.py

@@ -0,0 +1,70 @@
+from mapFolding import PackageSettings
+import dataclasses
+
+@dataclasses.dataclass
+class PackageInformation(PackageSettings):
+	callableDispatcher: str = 'doTheNeedful'
+	"""Name of the function within the dispatcher module that will be called."""
+
+	# "Evaluate When Packaging" and "Evaluate When Installing"
+	# https://github.com/hunterhogan/mapFolding/issues/18
+	dataclassIdentifier: str = dataclasses.field(default='ComputationState', metadata={'evaluateWhen': 'packaging'})
+	"""Name of the dataclass used to track computation state."""
+
+	dataclassInstance: str = dataclasses.field(default='state', metadata={'evaluateWhen': 'packaging'})
+	"""Default variable name for instances of the computation state dataclass."""
+
+	dataclassInstanceTaskDistributionSuffix: str = dataclasses.field(default='Parallel', metadata={'evaluateWhen': 'packaging'})
+	"""Suffix added to dataclassInstance for parallel task distribution."""
+
+	dataclassModule: str = dataclasses.field(default='beDRY', metadata={'evaluateWhen': 'packaging'})
+	"""Module containing the computation state dataclass definition."""
+
+	datatypePackage: str = dataclasses.field(default='numpy', metadata={'evaluateWhen': 'packaging'})
+	"""Package providing the numeric data types used in computation."""
+
+	sourceAlgorithm: str = dataclasses.field(default='theDao', metadata={'evaluateWhen': 'packaging'})
+	"""Module containing the reference implementation of the algorithm."""
+
+	sourceCallableDispatcher: str = dataclasses.field(default='doTheNeedful', metadata={'evaluateWhen': 'packaging'})
+	"""Name of the function that dispatches computation in the source algorithm."""
+
+	sourceCallableInitialize: str = dataclasses.field(default='countInitialize', metadata={'evaluateWhen': 'packaging'})
+	"""Name of the function that initializes computation in the source algorithm."""
+
+	sourceCallableParallel: str = dataclasses.field(default='countParallel', metadata={'evaluateWhen': 'packaging'})
+	"""Name of the function that performs parallel computation in the source algorithm."""
+
+	sourceCallableSequential: str = dataclasses.field(default='countSequential', metadata={'evaluateWhen': 'packaging'})
+	"""Name of the function that performs sequential computation in the source algorithm."""
+
+	sourceConcurrencyManagerIdentifier: str = dataclasses.field(default='submit', metadata={'evaluateWhen': 'packaging'})
+	"""Method name used to submit tasks to the concurrency manager."""
+
+	sourceConcurrencyManagerNamespace: str = dataclasses.field(default='concurrencyManager', metadata={'evaluateWhen': 'packaging'})
+	"""Variable name used for the concurrency manager instance."""
+
+	sourceConcurrencyPackage: str = dataclasses.field(default='multiprocessing', metadata={'evaluateWhen': 'packaging'})
+	"""Default package used for concurrency in the source algorithm."""
+
+	dataclassInstanceTaskDistribution: str = dataclasses.field(default=None, metadata={'evaluateWhen': 'packaging'}) # pyright: ignore[reportAssignmentType]
+	"""Variable name for the parallel distribution instance of the computation state."""
+
+	logicalPathModuleDataclass: str = dataclasses.field(default=None, metadata={'evaluateWhen': 'packaging'}) # pyright: ignore[reportAssignmentType]
+	"""Fully qualified import path to the module containing the computation state dataclass."""
+
+	logicalPathModuleSourceAlgorithm: str = dataclasses.field(default=None, metadata={'evaluateWhen': 'packaging'}) # pyright: ignore[reportAssignmentType]
+	"""Fully qualified import path to the module containing the source algorithm."""
+
+	def __post_init__(self) -> None:
+		if self.dataclassInstanceTaskDistribution is None: # pyright: ignore[reportUnnecessaryComparison]
+			self.dataclassInstanceTaskDistribution = self.dataclassInstance + self.dataclassInstanceTaskDistributionSuffix
+
+		if self.logicalPathModuleDataclass is None: # pyright: ignore[reportUnnecessaryComparison]
+			self.logicalPathModuleDataclass = '.'.join([self.packageName, self.dataclassModule])
+		if self.logicalPathModuleSourceAlgorithm is None: # pyright: ignore[reportUnnecessaryComparison]
+			self.logicalPathModuleSourceAlgorithm = '.'.join([self.packageName, self.sourceAlgorithm])
+
+class raiseIfNoneGitHubIssueNumber3(Exception): pass
+
+packageInformation = PackageInformation()

mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py

@@ -1,9 +1,10 @@
-from mapFolding import getPathFilenameFoldsTotal, raiseIfNoneGitHubIssueNumber3, The
-from mapFolding.someAssemblyRequired import (
+from mapFolding import getPathFilenameFoldsTotal, MapFoldingState
+from mapFolding.someAssemblyRequired import IfThis, packageInformation, raiseIfNoneGitHubIssueNumber3
+from astToolkit import (
 	ast_Identifier,
 	Be,
+	ClassIsAndAttribute,
 	extractFunctionDef,
-	IfThis,
 	IngredientsFunction,
 	IngredientsModule,
 	LedgerOfImports,
@@ -12,12 +13,11 @@ from mapFolding.someAssemblyRequired import (
 	NodeTourist,
 	str_nameDOTname,
 	Then,
-	write_astModule,
 )
+from astToolkit.transformationTools import write_astModule
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2Numba
-from mapFolding.someAssemblyRequired.toolboxNumba import parametersNumbaLight, SpicesJobNumba, decorateCallableWithNumba
+from mapFolding.someAssemblyRequired.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight, SpicesJobNumba
 from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
-from mapFolding.dataBaskets import MapFoldingState
 from pathlib import PurePosixPath
 from typing import cast, NamedTuple
 from Z0Z_tools import autoDecodingRLE
@@ -77,7 +77,7 @@ if __name__ == '__main__':
 	ast_argNumbaProgress = ast.arg(arg=spices.numbaProgressBarIdentifier, annotation=ast.Name(id=numba_progressPythonClass, ctx=ast.Load()))
 	ingredientsFunction.astFunctionDef.args.args.append(ast_argNumbaProgress)
 
-	findThis = IfThis.isAugAssignAndTargetIs(IfThis.isName_Identifier(job.shatteredDataclass.countingVariableName.id))
+	findThis = ClassIsAndAttribute.targetIs(ast.AugAssign, IfThis.isName_Identifier(job.shatteredDataclass.countingVariableName.id))
 	doThat = Then.replaceWith(Make.Expr(Make.Call(Make.Attribute(Make.Name(spices.numbaProgressBarIdentifier),'update'),[Make.Constant(1)])))
 	countWithProgressBar = NodeChanger(findThis, doThat)
 	countWithProgressBar.visit(ingredientsFunction.astFunctionDef)
@@ -161,10 +161,11 @@ def makeJobNumba(job: RecipeJobTheorem2Numba, spices: SpicesJobNumba) -> None:
 	ingredientsCount: IngredientsFunction = IngredientsFunction(astFunctionDef, LedgerOfImports())
 
 	# Remove `foldGroups` and any other unused statements, so you can dynamically determine which variables are not used
-	findThis = IfThis.isAssignAndTargets0Is(IfThis.isSubscript_Identifier('foldGroups'))
+	findThis = ClassIsAndAttribute.targetsIs(ast.Assign, lambda list_expr: any([IfThis.isSubscript_Identifier('foldGroups')(node) for node in list_expr ]))
+	# findThis = IfThis.isAssignAndTargets0Is(IfThis.isSubscript_Identifier('foldGroups'))
 	doThat = Then.removeIt
 	remove_foldGroups = NodeChanger(findThis, doThat)
-	remove_foldGroups.visit(ingredientsCount.astFunctionDef)
+	# remove_foldGroups.visit(ingredientsCount.astFunctionDef)
 
 	# replace identifiers with static values with their values, so you can dynamically determine which variables are not used
 	list_IdentifiersStaticValues = list_IdentifiersStaticValuesHARDCODED
@@ -183,7 +184,7 @@ def makeJobNumba(job: RecipeJobTheorem2Numba, spices: SpicesJobNumba) -> None:
 if __name__ == '__main__':
 	import time
 	timeStart = time.perf_counter()
-	foldsTotal = {job.countCallable}() * {job.state.leavesTotal}
+	foldsTotal = int({job.countCallable}() * {job.state.leavesTotal})
 	print(time.perf_counter() - timeStart)
 	print('\\nmap {job.state.mapShape} =', foldsTotal)
 	writeStream = open('{job.pathFilenameFoldsTotal.as_posix()}', 'w')
@@ -260,13 +261,13 @@ if __name__ == '__main__':
 	"""
 
 if __name__ == '__main__':
-	mapShape = (1,46)
+	mapShape = (2,4)
 	state = MapFoldingState(mapShape)
 	state = initializeGroupsOfFolds(state)
 	# foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal
 	# foldsTotalEstimated = dictionaryEstimates[state.mapShape] // state.leavesTotal
 	foldsTotalEstimated = 0
-	pathModule = PurePosixPath(The.pathPackage, 'jobs')
+	pathModule = PurePosixPath(packageInformation.pathPackage, 'jobs')
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
 	aJob = RecipeJobTheorem2Numba(state, foldsTotalEstimated, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
 	spices = SpicesJobNumba(useNumbaProgressBar=False, parametersNumba=parametersNumbaLight)

mapFolding/someAssemblyRequired/{toolboxNumba.py → toolkitNumba.py}

@@ -17,16 +17,13 @@ performance improvements while preserving code semantics and correctness.
 
 from collections.abc import Callable, Sequence
 from mapFolding import NotRequired, TypedDict
-from mapFolding.someAssemblyRequired import ast_Identifier, IngredientsFunction, Make, RecipeSynthesizeFlow, str_nameDOTname, write_astModule
-from mapFolding.someAssemblyRequired.transformationTools import makeNewFlow
+from astToolkit import ast_Identifier, IngredientsFunction, Make, str_nameDOTname
+from astToolkit.transformationTools import write_astModule
 from numba.core.compiler import CompilerBase as numbaCompilerBase
 from typing import Any, cast, Final
 import ast
 import dataclasses
 
-# Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
-theNumbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()
-
 class ParametersNumba(TypedDict):
 	_dbg_extend_lifetimes: NotRequired[bool]
 	_dbg_optnone: NotRequired[bool]
@@ -128,47 +125,8 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 	ingredientsFunction.astFunctionDef.decorator_list = [astDecorator]
 	return ingredientsFunction
 
-# Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
 @dataclasses.dataclass
 class SpicesJobNumba:
 	useNumbaProgressBar: bool = True
 	numbaProgressBarIdentifier: ast_Identifier = 'ProgressBarGroupsOfFolds'
 	parametersNumba: ParametersNumba = dataclasses.field(default_factory=ParametersNumba) # type: ignore
-
-# Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
-def makeNumbaFlow(numbaFlow: RecipeSynthesizeFlow) -> None:
-	"""
-	Transform standard Python algorithm code into optimized Numba implementations.
-
-	This function implements the complete transformation assembly line that converts
-	a conventional Python implementation into a high-performance Numba-accelerated
-	version. The process includes:
-
-	1. Extracting core algorithm functions from the source module
-	2. Inlining function calls to create self-contained implementations
-	3. Transforming dataclass access patterns for Numba compatibility
-	4. Applying appropriate Numba decorators with optimization settings
-	5. Generating a unified module with sequential and parallel implementations
-	6. Writing the transformed code to the filesystem with properly managed imports
-
-	The transformation preserves the logical structure and semantics of the original
-	implementation while making it compatible with Numba's constraints and
-	optimization capabilities. This creates a bridge between the general-purpose
-	implementation and the highly-optimized version needed for production use.
-
-	Parameters:
-		numbaFlow: Configuration object that specifies all aspects of the
-					transformation process, including source and target locations,
-					function and variable names, and output paths.
-	"""
-
-	ingredientsModuleNumbaUnified = makeNewFlow(numbaFlow)
-
-	# numba decorators =========================================
-	ingredientsModuleNumbaUnified.listIngredientsFunctions[1] = decorateCallableWithNumba(ingredientsModuleNumbaUnified.listIngredientsFunctions[1])
-	ingredientsModuleNumbaUnified.listIngredientsFunctions[2] = decorateCallableWithNumba(ingredientsModuleNumbaUnified.listIngredientsFunctions[2])
-
-	write_astModule(ingredientsModuleNumbaUnified, numbaFlow.pathFilenameDispatcher, numbaFlow.packageIdentifier)
-
-if __name__ == '__main__':
-	makeNumbaFlow(theNumbaFlow)

mapFolding/someAssemblyRequired/transformationTools.py

@@ -18,79 +18,27 @@ readable, maintainable implementations to highly optimized versions while preser
 logical structure and correctness.
 """
 
-from collections.abc import Callable
-from mapFolding.beDRY import outfitCountFolds
+from astToolkit import ClassIsAndAttribute
 from mapFolding.someAssemblyRequired import (
+	DeReConstructField2ast,
+	IfThis,
+	ShatteredDataclass,
+)
+from astToolkit import(
 	ast_Identifier,
-	astModuleToIngredientsFunction,
 	Be,
-	DeReConstructField2ast,
 	extractClassDef,
-	Grab,
-	IfThis,
-	importLogicalPath2Callable,
 	IngredientsFunction,
-	IngredientsModule,
-	inlineFunctionDef,
-	LedgerOfImports,
 	Make,
 	NodeChanger,
-	NodeTourist,
 	parseLogicalPath2astModule,
-	RecipeSynthesizeFlow,
-	removeUnusedParameters,
-	ShatteredDataclass,
 	str_nameDOTname,
 	Then,
-	unparseFindReplace,
 )
-from mapFolding.theSSOT import ComputationState, The
-from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal
-from os import PathLike
-from pathlib import Path, PurePath
-from typing import Any, Literal, overload
+from astToolkit.transformationTools import unparseFindReplace
+from Z0Z_tools import importLogicalPath2Callable
 import ast
 import dataclasses
-import pickle
-
-@overload
-def makeInitializedComputationState(mapShape: tuple[int, ...], writeJob: Literal[True], *,  pathFilename: PathLike[str] | PurePath | None = None, **keywordArguments: Any) -> Path: ...
-@overload
-def makeInitializedComputationState(mapShape: tuple[int, ...], writeJob: Literal[False] = False, **keywordArguments: Any) -> ComputationState: ...
-def makeInitializedComputationState(mapShape: tuple[int, ...], writeJob: bool = False, *,  pathFilename: PathLike[str] | PurePath | None = None, **keywordArguments: Any) -> ComputationState | Path:
-	"""
-	Initializes a computation state and optionally saves it to disk.
-
-	This function initializes a computation state using the source algorithm.
-
-	Hint: If you want an uninitialized state, call `outfitCountFolds` directly.
-
-	Parameters:
-		mapShape: List of integers representing the dimensions of the map to be folded.
-		writeJob (False): Whether to save the state to disk.
-		pathFilename (getPathFilenameFoldsTotal.pkl): The path and filename to save the state. If None, uses a default path.
-		**keywordArguments: computationDivisions:int|str|None=None,concurrencyLimit:int=1.
-	Returns:
-		stateUniversal|pathFilenameJob: The computation state for the map folding calculations, or
-			the path to the saved state file if writeJob is True.
-	"""
-	stateUniversal: ComputationState = outfitCountFolds(mapShape, **keywordArguments)
-
-	initializeState = importLogicalPath2Callable(The.logicalPathModuleSourceAlgorithm, The.sourceCallableInitialize)
-	stateUniversal = initializeState(stateUniversal)
-
-	if not writeJob:
-		return stateUniversal
-
-	if pathFilename:
-		pathFilenameJob = Path(pathFilename)
-		pathFilenameJob.parent.mkdir(parents=True, exist_ok=True)
-	else:
-		pathFilenameJob = getPathFilenameFoldsTotal(stateUniversal.mapShape).with_suffix('.pkl')
-
-	# Fix code scanning alert - Consider possible security implications associated with pickle module. #17
-	pathFilenameJob.write_bytes(pickle.dumps(stateUniversal))
-	return pathFilenameJob
 
 def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclass_Identifier: ast_Identifier, instance_Identifier: ast_Identifier) -> ShatteredDataclass:
 	"""
@@ -116,8 +64,8 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclas
 		instance_Identifier: The variable name to use for the dataclass instance in generated code.
 
 	Returns:
-		A ShatteredDataclass containing AST representations of all dataclass components,
-		with imports, field definitions, annotations, and repackaging code.
+		shatteredDataclass: A ShatteredDataclass containing AST representations of all dataclass components,
+			with imports, field definitions, annotations, and repackaging code.
 
 	Raises:
 		ValueError: If the dataclass cannot be found in the specified module or if no counting variable is identified in the dataclass.
@@ -136,7 +84,9 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclas
 			countingVariable = dictionaryDeReConstruction[aField.name].name
 
 	if countingVariable is None:
-		raise ValueError(f"I could not find the counting variable in `{dataclass_Identifier = }` in `{logicalPathModule = }`.")
+		import warnings
+		warnings.warn(message=f"I could not find the counting variable in `{dataclass_Identifier = }` in `{logicalPathModule = }`.", category=UserWarning)
+		raise Exception
 
 	shatteredDataclass = ShatteredDataclass(
 		countingVariableAnnotation=dictionaryDeReConstruction[countingVariable].astAnnotation,
@@ -160,114 +110,6 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclas
 	return shatteredDataclass
 
 # END of acceptable classes and functions ======================================================
-def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
-	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-	listAllIngredientsFunctions = [
-	(ingredientsInitialize := astModuleToIngredientsFunction(recipeFlow.source_astModule, recipeFlow.sourceCallableInitialize)),
-	(ingredientsParallel := astModuleToIngredientsFunction(recipeFlow.source_astModule, recipeFlow.sourceCallableParallel)),
-	(ingredientsSequential := astModuleToIngredientsFunction(recipeFlow.source_astModule, recipeFlow.sourceCallableSequential)),
-	(ingredientsDispatcher := astModuleToIngredientsFunction(recipeFlow.source_astModule, recipeFlow.sourceCallableDispatcher)),
-	]
-
-	# Inline functions ========================================================
-	# NOTE Replacements statements are based on the identifiers in the _source_, so operate on the source identifiers.
-	ingredientsInitialize.astFunctionDef = inlineFunctionDef(recipeFlow.sourceCallableInitialize, recipeFlow.source_astModule)
-	ingredientsParallel.astFunctionDef = inlineFunctionDef(recipeFlow.sourceCallableParallel, recipeFlow.source_astModule)
-	ingredientsSequential.astFunctionDef = inlineFunctionDef(recipeFlow.sourceCallableSequential, recipeFlow.source_astModule)
-
-	# assignRecipeIdentifiersToCallable. =============================
-	# Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
-	# How can I use dataclass settings as the SSOT for specific actions? https://github.com/hunterhogan/mapFolding/issues/16
-	# NOTE reminder: you are updating these `ast.Name` here (and not in a more general search) because this is a
-	# narrow search for `ast.Call` so you won't accidentally replace unrelated `ast.Name`.
-	listFindReplace = [(recipeFlow.sourceCallableDispatcher, recipeFlow.callableDispatcher),
-						(recipeFlow.sourceCallableInitialize, recipeFlow.callableInitialize),
-						(recipeFlow.sourceCallableParallel, recipeFlow.callableParallel),
-						(recipeFlow.sourceCallableSequential, recipeFlow.callableSequential),]
-	for ingredients in listAllIngredientsFunctions:
-		for source_Identifier, recipe_Identifier in listFindReplace:
-			updateCallName = NodeChanger(IfThis.isCall_Identifier(source_Identifier), Grab.funcAttribute(Then.replaceWith(Make.Name(recipe_Identifier))))
-			updateCallName.visit(ingredients.astFunctionDef)
-
-	ingredientsDispatcher.astFunctionDef.name = recipeFlow.callableDispatcher
-	ingredientsInitialize.astFunctionDef.name = recipeFlow.callableInitialize
-	ingredientsParallel.astFunctionDef.name = recipeFlow.callableParallel
-	ingredientsSequential.astFunctionDef.name = recipeFlow.callableSequential
-
-	# Assign identifiers per the recipe. ==============================
-	listFindReplace = [(recipeFlow.sourceDataclassInstance, recipeFlow.dataclassInstance),
-		(recipeFlow.sourceDataclassInstanceTaskDistribution, recipeFlow.dataclassInstanceTaskDistribution),
-		(recipeFlow.sourceConcurrencyManagerNamespace, recipeFlow.concurrencyManagerNamespace),]
-	for ingredients in listAllIngredientsFunctions:
-		for source_Identifier, recipe_Identifier in listFindReplace:
-			updateName = NodeChanger(IfThis.isName_Identifier(source_Identifier) , Grab.idAttribute(Then.replaceWith(recipe_Identifier)))
-			update_arg = NodeChanger(IfThis.isArgument_Identifier(source_Identifier), Grab.argAttribute(Then.replaceWith(recipe_Identifier)))
-			updateName.visit(ingredients.astFunctionDef)
-			update_arg.visit(ingredients.astFunctionDef)
-
-	updateConcurrencyManager = NodeChanger(IfThis.isCallAttributeNamespace_Identifier(recipeFlow.sourceConcurrencyManagerNamespace, recipeFlow.sourceConcurrencyManagerIdentifier)
-										, Grab.funcAttribute(Then.replaceWith(Make.Attribute(Make.Name(recipeFlow.concurrencyManagerNamespace), recipeFlow.concurrencyManagerIdentifier))))
-	updateConcurrencyManager.visit(ingredientsDispatcher.astFunctionDef)
-
-	# shatter Dataclass =======================================================
-	instance_Identifier = recipeFlow.dataclassInstance
-	getTheOtherRecord_damn = recipeFlow.dataclassInstanceTaskDistribution
-	shatteredDataclass = shatter_dataclassesDOTdataclass(recipeFlow.logicalPathModuleDataclass, recipeFlow.sourceDataclassIdentifier, instance_Identifier)
-	ingredientsDispatcher.imports.update(shatteredDataclass.imports)
-
-	# How can I use dataclass settings as the SSOT for specific actions? https://github.com/hunterhogan/mapFolding/issues/16
-	# Change callable parameters and Call to the callable at the same time ====
-	# sequentialCallable =========================================================
-	if recipeFlow.removeDataclassSequential:
-		ingredientsSequential = removeDataclassFromFunction(ingredientsSequential, shatteredDataclass)
-		ingredientsDispatcher = unpackDataclassCallFunctionRepackDataclass(ingredientsDispatcher, recipeFlow.callableSequential, shatteredDataclass)
-
-	if recipeFlow.removeDataclassInitialize:
-		ingredientsInitialize = removeDataclassFromFunction(ingredientsInitialize, shatteredDataclass)
-		ingredientsDispatcher = unpackDataclassCallFunctionRepackDataclass(ingredientsDispatcher, recipeFlow.callableInitialize, shatteredDataclass)
-
-	# parallelCallable =========================================================
-	if recipeFlow.removeDataclassParallel:
-		ingredientsParallel.astFunctionDef.args = Make.arguments(args=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
-
-		ingredientsParallel.astFunctionDef = unparseFindReplace(ingredientsParallel.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
-
-		ingredientsParallel = removeUnusedParameters(ingredientsParallel)
-
-		list_argCuzMyBrainRefusesToThink = ingredientsParallel.astFunctionDef.args.args + ingredientsParallel.astFunctionDef.args.posonlyargs + ingredientsParallel.astFunctionDef.args.kwonlyargs
-		list_arg_arg: list[ast_Identifier] = [ast_arg.arg for ast_arg in list_argCuzMyBrainRefusesToThink]
-
-		listParameters = [parameter for parameter in shatteredDataclass.listName4Parameters if parameter.id in list_arg_arg]
-
-		replaceCall2concurrencyManager = NodeChanger(IfThis.isCallAttributeNamespace_Identifier(recipeFlow.concurrencyManagerNamespace, recipeFlow.concurrencyManagerIdentifier), Then.replaceWith(Make.Call(Make.Attribute(Make.Name(recipeFlow.concurrencyManagerNamespace), recipeFlow.concurrencyManagerIdentifier), [Make.Name(recipeFlow.callableParallel)] + listParameters)))
-
-		def getIt(astCallConcurrencyResult: list[ast.Call]) -> Callable[[ast.AST], ast.AST]:
-			# TODO I cannot remember why I made this function. It doesn't fit with how I normally do things.
-			def workhorse(node: ast.AST) -> ast.AST:
-				NodeTourist(Be.Call, Then.appendTo(astCallConcurrencyResult)).visit(node)
-				return node
-			return workhorse
-
-		# NOTE I am dissatisfied with this logic for many reasons, including that it requires separate NodeCollector and NodeReplacer instances.
-		astCallConcurrencyResult: list[ast.Call] = []
-		get_astCallConcurrencyResult = NodeTourist(IfThis.isAssignAndTargets0Is(IfThis.isSubscript_Identifier(getTheOtherRecord_damn)), getIt(astCallConcurrencyResult))
-		get_astCallConcurrencyResult.visit(ingredientsDispatcher.astFunctionDef)
-		replaceAssignParallelCallable = NodeChanger(IfThis.isAssignAndTargets0Is(IfThis.isSubscript_Identifier(getTheOtherRecord_damn)), Grab.valueAttribute(Then.replaceWith(astCallConcurrencyResult[0])))
-		replaceAssignParallelCallable.visit(ingredientsDispatcher.astFunctionDef)
-		changeReturnParallelCallable = NodeChanger(Be.Return, Then.replaceWith(Make.Return(shatteredDataclass.countingVariableName)))
-		ingredientsParallel.astFunctionDef.returns = shatteredDataclass.countingVariableAnnotation
-
-		unpack4parallelCallable = NodeChanger(IfThis.isAssignAndValueIs(IfThis.isCallAttributeNamespace_Identifier(recipeFlow.concurrencyManagerNamespace, recipeFlow.concurrencyManagerIdentifier)), Then.insertThisAbove(shatteredDataclass.listUnpack))
-
-		unpack4parallelCallable.visit(ingredientsDispatcher.astFunctionDef)
-		replaceCall2concurrencyManager.visit(ingredientsDispatcher.astFunctionDef)
-		changeReturnParallelCallable.visit(ingredientsParallel.astFunctionDef)
-
-	# Module-level transformations ===========================================================
-	ingredientsModuleNumbaUnified = IngredientsModule(ingredientsFunction=listAllIngredientsFunctions, imports=LedgerOfImports(recipeFlow.source_astModule))
-	ingredientsModuleNumbaUnified.removeImportFromModule('numpy')
-
-	return ingredientsModuleNumbaUnified
 
 def removeDataclassFromFunction(ingredientsTarget: IngredientsFunction, shatteredDataclass: ShatteredDataclass) -> IngredientsFunction:
 	ingredientsTarget.astFunctionDef.args = Make.arguments(args=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
@@ -279,9 +121,9 @@ def removeDataclassFromFunction(ingredientsTarget: IngredientsFunction, shattere
 
 def unpackDataclassCallFunctionRepackDataclass(ingredientsCaller: IngredientsFunction, targetCallableIdentifier: ast_Identifier, shatteredDataclass: ShatteredDataclass) -> IngredientsFunction:
 	astCallTargetCallable = Make.Call(Make.Name(targetCallableIdentifier), shatteredDataclass.listName4Parameters)
-	replaceAssignTargetCallable = NodeChanger(IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(targetCallableIdentifier)), Then.replaceWith(Make.Assign([shatteredDataclass.fragments4AssignmentOrParameters], value=astCallTargetCallable)))
-	unpack4targetCallable = NodeChanger(IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(targetCallableIdentifier)), Then.insertThisAbove(shatteredDataclass.listUnpack))
-	repack4targetCallable = NodeChanger(IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(targetCallableIdentifier)), Then.insertThisBelow([shatteredDataclass.repack]))
+	replaceAssignTargetCallable = NodeChanger(ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCall_Identifier(targetCallableIdentifier)), Then.replaceWith(Make.Assign([shatteredDataclass.fragments4AssignmentOrParameters], value=astCallTargetCallable)))
+	unpack4targetCallable = NodeChanger(ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCall_Identifier(targetCallableIdentifier)), Then.insertThisAbove(shatteredDataclass.listUnpack))
+	repack4targetCallable = NodeChanger(ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCall_Identifier(targetCallableIdentifier)), Then.insertThisBelow([shatteredDataclass.repack]))
 	replaceAssignTargetCallable.visit(ingredientsCaller.astFunctionDef)
 	unpack4targetCallable.visit(ingredientsCaller.astFunctionDef)
 	repack4targetCallable.visit(ingredientsCaller.astFunctionDef)