mapFolding 0.8.3__py3-none-any.whl → 0.8.4__py3-none-any.whl

mapFolding/someAssemblyRequired/_toolboxPython.py

@@ -0,0 +1,76 @@
+from collections.abc import Callable
+from inspect import getsource as inspect_getsource
+from mapFolding.someAssemblyRequired import ast_Identifier, str_nameDOTname
+from os import PathLike
+from pathlib import Path, PurePath
+from types import ModuleType
+from typing import Any, Literal
+import ast
+import importlib
+import importlib.util
+
+# TODO Identify the logic that narrows the type and can help the user during static type checking.
+
+class NodeTourist(ast.NodeVisitor):
+    def __init__(self, findThis, doThat): # type: ignore
+        self.findThis = findThis
+        self.doThat = doThat
+        self.nodeCaptured = None
+
+    def visit(self, node): # type: ignore
+        if self.findThis(node):
+            nodeActionReturn = self.doThat(node) # type: ignore
+            if nodeActionReturn is not None:
+                self.nodeCaptured = nodeActionReturn # type: ignore
+        self.generic_visit(node)
+
+    def captureLastMatch(self, node): # type: ignore
+        """Capture the last matched node that produces a non-None result.
+
+        This method traverses the entire tree starting at the given node
+        and returns the last non-None value produced by applying doThat
+        to a matching node. It will continue traversing after finding a match,
+        and the value captured can be replaced by later matches.
+
+        Parameters:
+            node: The AST node to start traversal from
+
+        Returns:
+            The result of applying doThat to the last matching node that returned
+            a non-None value, or None if no match found or all matches returned None
+        """
+        self.nodeCaptured = None
+        self.visit(node) # type: ignore
+        return self.nodeCaptured
+
+class NodeChanger(ast.NodeTransformer):
+    def __init__(self, findThis, doThat): # type: ignore
+        self.findThis = findThis
+        self.doThat = doThat
+
+    def visit(self, node): # type: ignore
+        if self.findThis(node):
+            return self.doThat(node) # type: ignore
+        return super().visit(node)
+
+def importLogicalPath2Callable(logicalPathModule: str_nameDOTname, identifier: ast_Identifier, packageIdentifierIfRelative: ast_Identifier | None = None) -> Callable[..., Any]:
+    moduleImported: ModuleType = importlib.import_module(logicalPathModule, packageIdentifierIfRelative)
+    return getattr(moduleImported, identifier)
+
+def importPathFilename2Callable(pathFilename: PathLike[Any] | PurePath, identifier: ast_Identifier, moduleIdentifier: ast_Identifier | None = None) -> Callable[..., Any]:
+    pathFilename = Path(pathFilename)
+
+    importlibSpecification = importlib.util.spec_from_file_location(moduleIdentifier or pathFilename.stem, pathFilename)
+    if importlibSpecification is None or importlibSpecification.loader is None: raise ImportError(f"I received\n\t`{pathFilename = }`,\n\t`{identifier = }`, and\n\t`{moduleIdentifier = }`.\n\tAfter loading, \n\t`importlibSpecification` {'is `None`' if importlibSpecification is None else 'has a value'} and\n\t`importlibSpecification.loader` is unknown.")
+
+    moduleImported_jk_hahaha: ModuleType = importlib.util.module_from_spec(importlibSpecification)
+    importlibSpecification.loader.exec_module(moduleImported_jk_hahaha)
+    return getattr(moduleImported_jk_hahaha, identifier)
+
+def parseLogicalPath2astModule(logicalPathModule: str_nameDOTname, packageIdentifierIfRelative: ast_Identifier|None=None, mode:str='exec') -> ast.AST:
+    moduleImported: ModuleType = importlib.import_module(logicalPathModule, packageIdentifierIfRelative)
+    sourcePython: str = inspect_getsource(moduleImported)
+    return ast.parse(sourcePython, mode=mode)
+
+def parsePathFilename2astModule(pathFilename: PathLike[Any] | PurePath, mode:str='exec') -> ast.AST:
+    return ast.parse(Path(pathFilename).read_text(), mode=mode)

mapFolding/someAssemblyRequired/ingredientsNumba.py

@@ -20,7 +20,8 @@ algorithm implementation into a highly-optimized Numba version.
 """
 
 from collections.abc import Callable, Sequence
-from mapFolding.someAssemblyRequired import ifThis, IngredientsFunction, Make
+from mapFolding.someAssemblyRequired import Make
+from mapFolding.someAssemblyRequired._toolboxContainers import IngredientsFunction
 from numba.core.compiler import CompilerBase as numbaCompilerBase
 from typing import Any, cast, Final, TYPE_CHECKING
 import ast
@@ -71,10 +72,11 @@ parametersNumbaFailEarly: Final[ParametersNumba] = {
 		'no_cfunc_wrapper': False,
 		'no_cpython_wrapper': False,
 		'nopython': True,
-		'parallel': False, }
+		'parallel': False,
+}
 """For a production function: speed is irrelevant, error discovery is paramount, must be compatible with anything downstream."""
 
-parametersNumbaDEFAULT: Final[ParametersNumba] = {
+parametersNumbaDefault: Final[ParametersNumba] = {
 		'_nrt': True,
 		'boundscheck': False,
 		'cache': True,
@@ -90,13 +92,13 @@ parametersNumbaDEFAULT: Final[ParametersNumba] = {
 """Middle of the road: fast, lean, but will talk to non-jitted functions."""
 
 parametersNumbaParallelDEFAULT: Final[ParametersNumba] = {
-		**parametersNumbaDEFAULT,
+		**parametersNumbaDefault,
 		'_nrt': True,
 		'parallel': True, }
 """Middle of the road: fast, lean, but will talk to non-jitted functions."""
 
 parametersNumbaSuperJit: Final[ParametersNumba] = {
-		**parametersNumbaDEFAULT,
+		**parametersNumbaDefault,
 		'no_cfunc_wrapper': True,
 		'no_cpython_wrapper': True, }
 """Speed, no helmet, no talking to non-jitted functions."""
@@ -125,15 +127,6 @@ parametersNumbaMinimum: Final[ParametersNumba] = {
 Z0Z_numbaDataTypeModule = 'numba'
 Z0Z_decoratorCallable = 'jit'
 
-def thisIsNumbaDotJit(Ima: ast.AST) -> bool:
-	return ifThis.isCallNamespace_Identifier(Z0Z_numbaDataTypeModule, Z0Z_decoratorCallable)(Ima)
-
-def thisIsJit(Ima: ast.AST) -> bool:
-	return ifThis.isCall_Identifier(Z0Z_decoratorCallable)(Ima)
-
-def thisIsAnyNumbaJitDecorator(Ima: ast.AST) -> bool:
-	return thisIsNumbaDotJit(Ima) or thisIsJit(Ima)
-
 def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, parametersNumba: ParametersNumba | None = None) -> IngredientsFunction:
 	def Z0Z_UnhandledDecorators(astCallable: ast.FunctionDef) -> ast.FunctionDef:
 		# TODO: more explicit handling of decorators. I'm able to ignore this because I know `algorithmSource` doesn't have any decorators.
@@ -143,7 +136,7 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 			warnings.warn(f"Removed decorator {ast.unparse(decoratorItem)} from {astCallable.name}")
 		return astCallable
 
-	def makeSpecialSignatureForNumba(signatureElement: ast.arg) -> ast.Subscript | ast.Name | None:
+	def makeSpecialSignatureForNumba(signatureElement: ast.arg) -> ast.Subscript | ast.Name | None: # type: ignore
 		if isinstance(signatureElement.annotation, ast.Subscript) and isinstance(signatureElement.annotation.slice, ast.Tuple):
 			annotationShape: ast.expr = signatureElement.annotation.slice.elts[0]
 			if isinstance(annotationShape, ast.Subscript) and isinstance(annotationShape.slice, ast.Tuple):
@@ -162,7 +155,7 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 			ndarrayName = signatureElement.arg
 			Z0Z_hacky_dtype: str = ndarrayName
 			datatype_attr = datatypeAST or Z0Z_hacky_dtype
-			ingredientsFunction.imports.addImportFromStr(datatypeModuleDecorator, datatype_attr)
+			ingredientsFunction.imports.addImportFrom_asStr(datatypeModuleDecorator, datatype_attr)
 			datatypeNumba = ast.Name(id=datatype_attr, ctx=ast.Load())
 
 			return ast.Subscript(value=datatypeNumba, slice=shapeAST, ctx=ast.Load())
@@ -179,9 +172,9 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 		# Efficient translation of Python scalar types to Numba types https://github.com/hunterhogan/mapFolding/issues/8
 		# For now, let Numba infer them.
 		continue
-		signatureElement: ast.Subscript | ast.Name | None = makeSpecialSignatureForNumba(parameter)
-		if signatureElement:
-			list_arg4signature_or_function.append(signatureElement)
+		# signatureElement: ast.Subscript | ast.Name | None = makeSpecialSignatureForNumba(parameter)
+		# if signatureElement:
+		# 	list_arg4signature_or_function.append(signatureElement)
 
 	if ingredientsFunction.astFunctionDef.returns and isinstance(ingredientsFunction.astFunctionDef.returns, ast.Name):
 		theReturn: ast.Name = ingredientsFunction.astFunctionDef.returns
@@ -192,15 +185,15 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 
 	ingredientsFunction.astFunctionDef = Z0Z_UnhandledDecorators(ingredientsFunction.astFunctionDef)
 	if parametersNumba is None:
-		parametersNumba = parametersNumbaDEFAULT
-	listDecoratorKeywords: list[ast.keyword] = [Make.ast_keyword(parameterName, Make.astConstant(parameterValue)) for parameterName, parameterValue in parametersNumba.items()]
+		parametersNumba = parametersNumbaDefault
+	listDecoratorKeywords: list[ast.keyword] = [Make.keyword(parameterName, Make.Constant(parameterValue)) for parameterName, parameterValue in parametersNumba.items()]
 
 	decoratorModule: str = Z0Z_numbaDataTypeModule
 	decoratorCallable: str = Z0Z_decoratorCallable
-	ingredientsFunction.imports.addImportFromStr(decoratorModule, decoratorCallable)
+	ingredientsFunction.imports.addImportFrom_asStr(decoratorModule, decoratorCallable)
 	# Leave this line in so that global edits will change it.
-	astDecorator: ast.Call = Make.astCall(Make.astName(decoratorCallable), list_argsDecorator, listDecoratorKeywords)
-	astDecorator: ast.Call = Make.astCall(Make.astName(decoratorCallable), list_astKeywords=listDecoratorKeywords) # type: ignore[no-redef]
+	astDecorator: ast.Call = Make.Call(Make.Name(decoratorCallable), list_argsDecorator, listDecoratorKeywords)
+	astDecorator: ast.Call = Make.Call(Make.Name(decoratorCallable), list_astKeywords=listDecoratorKeywords)
 
 	ingredientsFunction.astFunctionDef.decorator_list = [astDecorator]
 	return ingredientsFunction

mapFolding/someAssemblyRequired/synthesizeNumbaFlow.py

@@ -22,190 +22,135 @@ to generate a fresh optimized implementation.
 """
 
 from mapFolding.someAssemblyRequired import (
-	ast_Identifier,
-	extractFunctionDef,
+	be,
 	ifThis,
-	IngredientsFunction,
+	Make,
+	NodeChanger,
+	NodeTourist,
+	Then,
+	Z0Z_inlineThisFunctionWithTheseValues,
+	Z0Z_lameFindReplace,
+	Z0Z_makeDictionaryReplacementStatements,
+	又,
+)
+from mapFolding.someAssemblyRequired._toolboxContainers import (
+	astModuleToIngredientsFunction,
 	IngredientsModule,
 	LedgerOfImports,
-	Make,
-	makeDictionaryReplacementStatements,
-	NodeCollector,
-	NodeReplacer,
 	RecipeSynthesizeFlow,
-	Then,
-	write_astModule,
-	Z0Z_replaceMatchingASTnodes,
-	inlineThisFunctionWithTheseValues,
 )
 from mapFolding.someAssemblyRequired.ingredientsNumba import decorateCallableWithNumba
 from mapFolding.someAssemblyRequired.transformDataStructures import shatter_dataclassesDOTdataclass
-from mapFolding.theSSOT import raiseIfNoneGitHubIssueNumber3
+from mapFolding.someAssemblyRequired.transformationTools import write_astModule
 import ast
 
-def astModuleToIngredientsFunction(astModule: ast.Module, identifierFunctionDef: ast_Identifier) -> IngredientsFunction:
-	astFunctionDef = extractFunctionDef(astModule, identifierFunctionDef)
-	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
-	return IngredientsFunction(astFunctionDef, LedgerOfImports(astModule))
-
-
-def makeNumbaFlow(numbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()) -> None:
+def makeNumbaFlow(numbaFlow: RecipeSynthesizeFlow) -> None:
 	# TODO a tool to automatically remove unused variables from the ArgumentsSpecification (return, and returns) _might_ be nice.
-	# TODO remember that `sequentialCallable` and `sourceSequentialCallable` are two different values.
 	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-	# ===========================================================
-	"""
-	Think about a better organization of this function.
-
-	Currently, transform `Callable` in order:
-		sourceDispatcherCallable
-		sourceInitializeCallable
-		sourceParallelCallable
-		sourceSequentialCallable
-
-	But, it should be organized around each transformation. So, when the parameters of `sourceSequentialCallable`
-	are transformed, for example, the statement in `sourceDispatcherCallable` that calls `sourceSequentialCallable` should be
-	transformed at the same time: literally in the same function-or-NodeReplacer-or-subroutine. That would help
-	avoid bugs.
-
-	Furthermore, if the above example transformation requires unpacking the dataclass, for example, then the unpacking
-	would be automatically triggered. I have no idea how that would happen, but the transformations are highly predictable,
-	so using a programming language to construct if-this-then-that cascades shouldn't be a problem, you know?
-
-	"""
-	ingredientsDispatcher: IngredientsFunction = astModuleToIngredientsFunction(numbaFlow.source_astModule, numbaFlow.sourceDispatcherCallable)
-	ingredientsInitialize: IngredientsFunction = astModuleToIngredientsFunction(numbaFlow.source_astModule, numbaFlow.sourceInitializeCallable)
-	ingredientsParallel: IngredientsFunction = astModuleToIngredientsFunction(numbaFlow.source_astModule, numbaFlow.sourceParallelCallable)
-	ingredientsSequential: IngredientsFunction = astModuleToIngredientsFunction(numbaFlow.source_astModule, numbaFlow.sourceSequentialCallable)
-
-	# Inline functions
-	# NOTE Replacements statements are based on the identifiers in the _source_
-	dictionaryReplacementStatements = makeDictionaryReplacementStatements(numbaFlow.source_astModule)
-	ingredientsInitialize.astFunctionDef = inlineThisFunctionWithTheseValues(ingredientsInitialize.astFunctionDef, dictionaryReplacementStatements)
-	ingredientsParallel.astFunctionDef = inlineThisFunctionWithTheseValues(ingredientsParallel.astFunctionDef, dictionaryReplacementStatements)
-	ingredientsSequential.astFunctionDef = inlineThisFunctionWithTheseValues(ingredientsSequential.astFunctionDef, dictionaryReplacementStatements)
-
-	# Assign CALLABLE identifiers per the recipe.
-	# TODO Assign the other identifiers.
-	listIngredientsFunctions = [ingredientsDispatcher, ingredientsInitialize, ingredientsParallel, ingredientsSequential]
-	listFindReplace = [(numbaFlow.sourceDispatcherCallable, numbaFlow.dispatcherCallable),
-		(numbaFlow.sourceInitializeCallable, numbaFlow.initializeCallable),
-		(numbaFlow.sourceParallelCallable, numbaFlow.parallelCallable),
-		(numbaFlow.sourceSequentialCallable, numbaFlow.sequentialCallable)]
-	for ingredients in listIngredientsFunctions:
-		ImaNode = ingredients.astFunctionDef
-		for source_Identifier, Z0Z_Identifier in listFindReplace:
-			findThis = ifThis.isCall_Identifier(source_Identifier)
-			doThis = Then.replaceDOTfuncWith(Make.astName(Z0Z_Identifier))
-			NodeReplacer(findThis, doThis).visit(ImaNode)
-
-	ingredientsDispatcher.astFunctionDef.name = numbaFlow.dispatcherCallable
-	ingredientsInitialize.astFunctionDef.name = numbaFlow.initializeCallable
-	ingredientsParallel.astFunctionDef.name = numbaFlow.parallelCallable
-	ingredientsSequential.astFunctionDef.name = numbaFlow.sequentialCallable
-	# ===========================================================
-	# Old organization
-
-	# sourceParallelCallable
-	shatteredDataclass = shatter_dataclassesDOTdataclass(numbaFlow.logicalPathModuleDataclass, numbaFlow.sourceDataclassIdentifier, numbaFlow.sourceDataclassInstanceTaskDistribution)
-	ingredientsDispatcher.imports.update(shatteredDataclass.ledgerDataclassANDFragments)
-
-	NodeReplacer(
-		findThis = ifThis.isAssignAndValueIsCallNamespace_Identifier(numbaFlow.sourceConcurrencyManagerNamespace, numbaFlow.sourceConcurrencyManagerIdentifier)
-		, doThat = Then.insertThisAbove(shatteredDataclass.listAnnAssign4DataclassUnpack)
-			).visit(ingredientsDispatcher.astFunctionDef)
-	NodeReplacer(
-		findThis = ifThis.isCallNamespace_Identifier(numbaFlow.sourceConcurrencyManagerNamespace, numbaFlow.sourceConcurrencyManagerIdentifier)
-		, doThat = Then.replaceWith(Make.astCall(Make.astAttribute(Make.astName(numbaFlow.sourceConcurrencyManagerNamespace), numbaFlow.sourceConcurrencyManagerIdentifier)
-									, listArguments=[Make.astName(numbaFlow.parallelCallable)] + shatteredDataclass.listNameDataclassFragments4Parameters))
-			).visit(ingredientsDispatcher.astFunctionDef)
-
-	CapturedAssign: list[ast.AST] = []
-	CapturedCall: list[ast.Call] = []
-	findThis = ifThis.isCall
-	doThat = [Then.appendTo(CapturedCall)]
-	capture = NodeCollector(findThis, doThat)
-
-	NodeCollector(
-		findThis = ifThis.isAssignAndTargets0Is(ifThis.isSubscript_Identifier(numbaFlow.sourceDataclassInstance))
-		, doThat = [Then.appendTo(CapturedAssign)
-					, lambda node: capture.visit(node)]
-			).visit(ingredientsDispatcher.astFunctionDef)
-
-	newAssign = CapturedAssign[0]
-	NodeReplacer(
-		findThis = lambda node: ifThis.isSubscript(node) and ifThis.isAttribute(node.value) and ifThis.isCall(node.value.value)
-		, doThat = Then.replaceWith(CapturedCall[0])
-			).visit(newAssign)
-
-	NodeReplacer(
-		findThis = ifThis.isAssignAndTargets0Is(ifThis.isSubscript_Identifier(numbaFlow.sourceDataclassInstance))
-		, doThat = Then.replaceWith(newAssign)
-			).visit(ingredientsDispatcher.astFunctionDef)
-
-	# sourceSequentialCallable
-	shatteredDataclass = shatter_dataclassesDOTdataclass(numbaFlow.logicalPathModuleDataclass, numbaFlow.sourceDataclassIdentifier, numbaFlow.sourceDataclassInstance)
-
-	ingredientsDispatcher.imports.update(shatteredDataclass.ledgerDataclassANDFragments)
-
-	NodeReplacer(
-		findThis = ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.sourceSequentialCallable) # NOTE source
-		, doThat = Then.insertThisAbove(shatteredDataclass.listAnnAssign4DataclassUnpack)
-			).visit(ingredientsDispatcher.astFunctionDef)
-	NodeReplacer(
-		findThis = ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.sourceSequentialCallable) # NOTE source
-		, doThat = Then.insertThisBelow([shatteredDataclass.astAssignDataclassRepack])
-			).visit(ingredientsDispatcher.astFunctionDef)
-	NodeReplacer(
-		findThis = ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.sourceSequentialCallable) # NOTE source
-		, doThat = Then.replaceWith(Make.astAssign(listTargets=[shatteredDataclass.astTuple4AssignTargetsToFragments], value=Make.astCall(Make.astName(numbaFlow.sequentialCallable), shatteredDataclass.listNameDataclassFragments4Parameters)))
-			).visit(ingredientsDispatcher.astFunctionDef)
-
-
-	# ===========================================================
-	ingredientsParallel.astFunctionDef.args = Make.astArgumentsSpecification(args=shatteredDataclass.list_ast_argAnnotated4ArgumentsSpecification)
-	NodeReplacer(
-		findThis = ifThis.isReturn
-		, doThat = Then.replaceWith(Make.astReturn(shatteredDataclass.astTuple4AssignTargetsToFragments))
-			).visit(ingredientsParallel.astFunctionDef)
-
-	NodeReplacer(
-		findThis = ifThis.isReturn
-		, doThat = Then.replaceWith(Make.astReturn(shatteredDataclass.countingVariableName))
-			).visit(ingredientsParallel.astFunctionDef)
+
+	listAllIngredientsFunctions = [
+	(ingredientsInitialize := astModuleToIngredientsFunction(numbaFlow.source_astModule, numbaFlow.sourceCallableInitialize)),
+	(ingredientsParallel := astModuleToIngredientsFunction(numbaFlow.source_astModule, numbaFlow.sourceCallableParallel)),
+	(ingredientsSequential := astModuleToIngredientsFunction(numbaFlow.source_astModule, numbaFlow.sourceCallableSequential)),
+	(ingredientsDispatcher := astModuleToIngredientsFunction(numbaFlow.source_astModule, numbaFlow.sourceCallableDispatcher)),
+	]
+
+	# Inline functions ========================================================
+	dictionaryReplacementStatements = Z0Z_makeDictionaryReplacementStatements(numbaFlow.source_astModule)
+	# NOTE Replacements statements are based on the identifiers in the _source_, so operate on the source identifiers.
+	ingredientsInitialize.astFunctionDef = Z0Z_inlineThisFunctionWithTheseValues(ingredientsInitialize.astFunctionDef, dictionaryReplacementStatements)
+	ingredientsParallel.astFunctionDef = Z0Z_inlineThisFunctionWithTheseValues(ingredientsParallel.astFunctionDef, dictionaryReplacementStatements)
+	ingredientsSequential.astFunctionDef = Z0Z_inlineThisFunctionWithTheseValues(ingredientsSequential.astFunctionDef, dictionaryReplacementStatements)
+
+	# assignRecipeIdentifiersToCallable. =============================
+	# TODO How can I use `RecipeSynthesizeFlow` as the SSOT for the pairs of items that may need to be replaced?
+	# 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 = [(numbaFlow.sourceCallableDispatcher, numbaFlow.callableDispatcher),
+						(numbaFlow.sourceCallableInitialize, numbaFlow.callableInitialize),
+						(numbaFlow.sourceCallableParallel, numbaFlow.callableParallel),
+						(numbaFlow.sourceCallableSequential, numbaFlow.callableSequential),]
+	for ingredients in listAllIngredientsFunctions:
+		for source_Identifier, recipe_Identifier in listFindReplace:
+			updateCallName = NodeChanger(ifThis.isCall_Identifier(source_Identifier), Then.DOTfunc(Then.replaceWith(Make.Name(recipe_Identifier))))
+			updateCallName.visit(ingredients.astFunctionDef)
+
+	ingredientsDispatcher.astFunctionDef.name = numbaFlow.callableDispatcher
+	ingredientsInitialize.astFunctionDef.name = numbaFlow.callableInitialize
+	ingredientsParallel.astFunctionDef.name = numbaFlow.callableParallel
+	ingredientsSequential.astFunctionDef.name = numbaFlow.callableSequential
+
+	# Assign identifiers per the recipe. ==============================
+	listFindReplace = [(numbaFlow.sourceDataclassInstance, numbaFlow.dataclassInstance),
+		(numbaFlow.sourceDataclassInstanceTaskDistribution, numbaFlow.dataclassInstanceTaskDistribution),
+		(numbaFlow.sourceConcurrencyManagerNamespace, numbaFlow.concurrencyManagerNamespace),]
+	for ingredients in listAllIngredientsFunctions:
+		for source_Identifier, recipe_Identifier in listFindReplace:
+			updateName = NodeChanger(ifThis.isName_Identifier(source_Identifier), Then.DOTid(Then.replaceWith(recipe_Identifier)))
+			update_arg = NodeChanger(ifThis.isArgument_Identifier(source_Identifier), Then.DOTarg(Then.replaceWith(recipe_Identifier)))
+			updateName.visit(ingredients.astFunctionDef)
+			update_arg.visit(ingredients.astFunctionDef)
+
+	updateConcurrencyManager = NodeChanger(ifThis.isCallAttributeNamespace_Identifier(numbaFlow.sourceConcurrencyManagerNamespace, numbaFlow.sourceConcurrencyManagerIdentifier)
+										, Then.DOTfunc(Then.replaceWith(Make.Attribute(Make.Name(numbaFlow.concurrencyManagerNamespace), numbaFlow.concurrencyManagerIdentifier))))
+	updateConcurrencyManager.visit(ingredientsDispatcher.astFunctionDef)
+
+	# shatter Dataclass =======================================================
+	instance_Identifier = numbaFlow.dataclassInstance
+	getTheOtherRecord_damn = numbaFlow.dataclassInstanceTaskDistribution
+	shatteredDataclass = shatter_dataclassesDOTdataclass(numbaFlow.logicalPathModuleDataclass, numbaFlow.sourceDataclassIdentifier, instance_Identifier)
+	ingredientsDispatcher.imports.update(shatteredDataclass.ledger)
+
+	# Change callable parameters and Call to the callable at the same time ====
+	# TODO How can I use ast and/or other tools to ensure that when I change a callable, I also change the statements that call the callable?
+	# Asked differently, how do I integrate separate statements into a "subroutine", and that subroutine is "atomic/indivisible"?
+	# sequentialCallable =========================================================
+	ingredientsSequential.astFunctionDef.args = Make.argumentsSpecification(args=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
+	astCallSequentialCallable = Make.Call(Make.Name(numbaFlow.callableSequential), shatteredDataclass.listName4Parameters)
+	changeReturnSequentialCallable = NodeChanger(be.Return, Then.replaceWith(Make.Return(shatteredDataclass.fragments4AssignmentOrParameters)))
+	ingredientsSequential.astFunctionDef.returns = shatteredDataclass.signatureReturnAnnotation
+	replaceAssignSequentialCallable = NodeChanger(ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.callableSequential), Then.replaceWith(Make.Assign(listTargets=[shatteredDataclass.fragments4AssignmentOrParameters], value=astCallSequentialCallable)))
+
+	unpack4sequentialCallable = NodeChanger(ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.callableSequential), Then.insertThisAbove(shatteredDataclass.listUnpack))
+	repack4sequentialCallable = NodeChanger(ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.callableSequential), Then.insertThisBelow([shatteredDataclass.repack]))
+
+	changeReturnSequentialCallable.visit(ingredientsSequential.astFunctionDef)
+	replaceAssignSequentialCallable.visit(ingredientsDispatcher.astFunctionDef)
+	unpack4sequentialCallable.visit(ingredientsDispatcher.astFunctionDef)
+	repack4sequentialCallable.visit(ingredientsDispatcher.astFunctionDef)
+
+	ingredientsSequential.astFunctionDef = Z0Z_lameFindReplace(ingredientsSequential.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
+
+	# parallelCallable =========================================================
+	ingredientsParallel.astFunctionDef.args = Make.argumentsSpecification(args=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
+	replaceCall2concurrencyManager = NodeChanger(ifThis.isCallAttributeNamespace_Identifier(numbaFlow.concurrencyManagerNamespace, numbaFlow.concurrencyManagerIdentifier), Then.replaceWith(Make.Call(Make.Attribute(Make.Name(numbaFlow.concurrencyManagerNamespace), numbaFlow.concurrencyManagerIdentifier), listArguments=[Make.Name(numbaFlow.callableParallel)] + shatteredDataclass.listName4Parameters)))
+
+	# 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 = NodeTourist(ifThis.isAssignAndTargets0Is(ifThis.isSubscript_Identifier(getTheOtherRecord_damn)), lambda node: NodeTourist(be.Call, Then.appendTo(astCallConcurrencyResult)).visit(node)) # pyright: ignore[reportUnknownArgumentType, reportUnknownLambdaType]
+	get_astCallConcurrencyResult.visit(ingredientsDispatcher.astFunctionDef)
+	replaceAssignParallelCallable = NodeChanger(ifThis.isAssignAndTargets0Is(ifThis.isSubscript_Identifier(getTheOtherRecord_damn)), Then.DOTvalue(Then.replaceWith(astCallConcurrencyResult[0])))
+	replaceAssignParallelCallable.visit(ingredientsDispatcher.astFunctionDef)
+	changeReturnParallelCallable = NodeChanger(be.Return, Then.replaceWith(Make.Return(shatteredDataclass.countingVariableName)))
 	ingredientsParallel.astFunctionDef.returns = shatteredDataclass.countingVariableAnnotation
-	replacementMap = {statement.value: statement.target for statement in shatteredDataclass.listAnnAssign4DataclassUnpack}
-	ingredientsParallel.astFunctionDef = Z0Z_replaceMatchingASTnodes(ingredientsParallel.astFunctionDef, replacementMap) # type: ignore
-	ingredientsParallel = decorateCallableWithNumba(ingredientsParallel)
 
-	# ===========================================================
-	ingredientsSequential.astFunctionDef.args = Make.astArgumentsSpecification(args=shatteredDataclass.list_ast_argAnnotated4ArgumentsSpecification)
-	NodeReplacer(
-		findThis = ifThis.isReturn
-		, doThat = Then.replaceWith(Make.astReturn(shatteredDataclass.astTuple4AssignTargetsToFragments))
-			).visit(ingredientsSequential.astFunctionDef)
-	NodeReplacer(
-		findThis = ifThis.isReturn
-		, doThat = Then.replaceWith(Make.astReturn(shatteredDataclass.astTuple4AssignTargetsToFragments))
-			).visit(ingredientsSequential.astFunctionDef)
-	ingredientsSequential.astFunctionDef.returns = shatteredDataclass.astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns
-	replacementMap = {statement.value: statement.target for statement in shatteredDataclass.listAnnAssign4DataclassUnpack}
-	ingredientsSequential.astFunctionDef = Z0Z_replaceMatchingASTnodes(ingredientsSequential.astFunctionDef, replacementMap) # type: ignore
+	unpack4parallelCallable = NodeChanger(ifThis.isAssignAndValueIsCallAttributeNamespace_Identifier(numbaFlow.concurrencyManagerNamespace, numbaFlow.concurrencyManagerIdentifier), Then.insertThisAbove(shatteredDataclass.listUnpack))
+
+	unpack4parallelCallable.visit(ingredientsDispatcher.astFunctionDef)
+	replaceCall2concurrencyManager.visit(ingredientsDispatcher.astFunctionDef)
+	changeReturnParallelCallable.visit(ingredientsParallel.astFunctionDef)
+
+	ingredientsParallel.astFunctionDef = Z0Z_lameFindReplace(ingredientsParallel.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
+
+	# numba decorators =========================================
+	ingredientsParallel = decorateCallableWithNumba(ingredientsParallel)
 	ingredientsSequential = decorateCallableWithNumba(ingredientsSequential)
-	# End old organization
-	# ===========================================================
 
-	# ===========================================================
-	# End function-level transformations
-	# ===========================================================
-	# Module-level transformations
-	ingredientsModuleNumbaUnified = IngredientsModule(
-		ingredientsFunction=[ingredientsInitialize,
-							ingredientsParallel,
-							ingredientsSequential,
-							ingredientsDispatcher], imports=LedgerOfImports(numbaFlow.source_astModule))
+	# Module-level transformations ===========================================================
+	ingredientsModuleNumbaUnified = IngredientsModule(ingredientsFunction=listAllIngredientsFunctions, imports=LedgerOfImports(numbaFlow.source_astModule))
 
-	write_astModule(ingredientsModuleNumbaUnified, numbaFlow.pathFilenameDispatcher, numbaFlow.packageName)
+	write_astModule(ingredientsModuleNumbaUnified, numbaFlow.pathFilenameDispatcher, numbaFlow.packageIdentifier)
 
+theNumbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()
 if __name__ == '__main__':
-	makeNumbaFlow()
+	makeNumbaFlow(theNumbaFlow)