mapFolding 0.8.6__py3-none-any.whl → 0.9.1__py3-none-any.whl

mapFolding/someAssemblyRequired/toolboxNumba.py

@@ -1,46 +1,39 @@
 """
-Numba-specific ingredients for optimized code generation.
+Numba-specific Tools for Generating Optimized Code
 
-This module provides specialized tools, constants, and types specifically designed
-for transforming Python code into Numba-accelerated implementations. It implements:
+This module provides specialized tools for transforming standard Python code into
+Numba-accelerated implementations. It implements a comprehensive transformation
+assembly-line that:
 
-1. A range of Numba jit decorator configurations for different optimization scenarios
-2. Functions to identify and manipulate Numba decorators in abstract syntax trees
-3. Utilities for applying appropriate Numba typing to transformed code
-4. Parameter management for Numba compilation options
+1. Converts dataclass-based algorithm implementations into Numba-compatible versions.
+2. Applies appropriate Numba decorators with optimized configuration settings.
+3. Restructures code to work within Numba's constraints.
+4. Manages type information for optimized compilation.
 
-The configurations range from conservative options that prioritize compatibility and
-error detection to aggressive optimizations that maximize performance at the cost of
-flexibility. While this module specifically targets Numba, its design follows the pattern
-of generic code transformation tools in the package, allowing similar approaches to be
-applied to other acceleration technologies.
-
-This module works in conjunction with transformation tools to convert the general-purpose
-algorithm implementation into a highly-optimized Numba version.
+The module bridges the gap between readable, maintainable Python code and
+highly-optimized numerical computing implementations, enabling significant
+performance improvements while preserving code semantics and correctness.
 """
 
 from collections.abc import Callable, Sequence
-from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal, getPathRootJobDEFAULT
-from mapFolding.someAssemblyRequired import IngredientsModule, LedgerOfImports, Make, NodeChanger, NodeTourist, RecipeSynthesizeFlow, Then, ast_Identifier, be, ifThis, parsePathFilename2astModule, str_nameDOTname, IngredientsFunction, ShatteredDataclass
-from mapFolding.someAssemblyRequired.transformationTools import Z0Z_inlineThisFunctionWithTheseValues, Z0Z_lameFindReplace, Z0Z_makeDictionaryReplacementStatements, astModuleToIngredientsFunction, shatter_dataclassesDOTdataclass, write_astModule
-from mapFolding.theSSOT import ComputationState, DatatypeFoldsTotal as TheDatatypeFoldsTotal, DatatypeElephino as TheDatatypeElephino, DatatypeLeavesTotal as TheDatatypeLeavesTotal
-
+from mapFolding.someAssemblyRequired import Make, NodeTourist, RecipeSynthesizeFlow, Then, ast_Identifier, str_nameDOTname, IngredientsFunction
+from mapFolding.someAssemblyRequired.transformationTools import ( makeNewFlow, write_astModule, )
 from numba.core.compiler import CompilerBase as numbaCompilerBase
-from pathlib import Path, PurePosixPath
-from typing import Any, cast, Final, TYPE_CHECKING, TypeAlias
+from typing import Any, cast, Final, TYPE_CHECKING, TypeGuard
 import ast
 import dataclasses
 
 try:
 	from typing import NotRequired
 except Exception:
-	from typing_extensions import NotRequired
+	from typing_extensions import NotRequired # pyright: ignore[reportShadowedImports]
 
 if TYPE_CHECKING:
 	from typing import TypedDict
 else:
 	TypedDict = dict[str,Any]
 
+# Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
 theNumbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()
 
 class ParametersNumba(TypedDict):
@@ -52,17 +45,17 @@ class ParametersNumba(TypedDict):
 	debug: NotRequired[bool]
 	error_model: str
 	fastmath: bool
-	forceinline: bool
+	forceinline: NotRequired[bool]
 	forceobj: NotRequired[bool]
-	inline: str
+	inline: NotRequired[str]
 	locals: NotRequired[dict[str, Any]]
-	looplift: bool
-	no_cfunc_wrapper: bool
-	no_cpython_wrapper: bool
+	looplift: NotRequired[bool]
+	no_cfunc_wrapper: NotRequired[bool]
+	no_cpython_wrapper: NotRequired[bool]
 	no_rewrites: NotRequired[bool]
 	nogil: NotRequired[bool]
-	nopython: bool
-	parallel: bool
+	nopython: NotRequired[bool]
+	parallel: NotRequired[bool]
 	pipeline_class: NotRequired[type[numbaCompilerBase]]
 	signature_or_function: NotRequired[Any | Callable[..., Any] | str | tuple[Any, ...]]
 	target: NotRequired[str]
@@ -78,6 +71,7 @@ parametersNumbaSuperJit: Final[ParametersNumba] = { **parametersNumbaDefault, 'n
 parametersNumbaSuperJitParallel: Final[ParametersNumba] = { **parametersNumbaSuperJit, '_nrt': True, 'parallel': True, }
 """Speed, no helmet, concurrency, no talking to non-jitted functions."""
 parametersNumbaMinimum: Final[ParametersNumba] = { '_nrt': True, 'boundscheck': True, 'cache': True, 'error_model': 'numpy', 'fastmath': True, 'forceinline': False, 'inline': 'always', 'looplift': False, 'no_cfunc_wrapper': False, 'no_cpython_wrapper': False, 'nopython': False, 'forceobj': True, 'parallel': False, }
+parametersNumbaLight: Final[ParametersNumba] = {'cache': True, 'error_model': 'numpy', 'fastmath': True, 'forceinline': True}
 
 Z0Z_numbaDataTypeModule: str_nameDOTname = 'numba'
 Z0Z_decoratorCallable: ast_Identifier = 'jit'
@@ -91,7 +85,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: # type: ignore
+	def makeSpecialSignatureForNumba(signatureElement: ast.arg) -> ast.Subscript | ast.Name | None: # pyright: ignore[reportUnusedFunction]
 		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):
@@ -125,10 +119,10 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 	list_arg4signature_or_function: list[ast.expr] = []
 	for parameter in ingredientsFunction.astFunctionDef.args.args:
 		# For now, let Numba infer them.
+		signatureElement: ast.Subscript | ast.Name | None = makeSpecialSignatureForNumba(parameter)
+		if signatureElement:
+			list_arg4signature_or_function.append(signatureElement)
 		continue
-		# 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
@@ -152,213 +146,61 @@ 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 = parametersNumbaDefault
+	parametersNumba: ParametersNumba = dataclasses.field(default_factory=ParametersNumba) # type: ignore
 
-@dataclasses.dataclass
-class RecipeJob:
-	state: ComputationState
-	# TODO create function to calculate `foldsTotalEstimated`
-	foldsTotalEstimated: int = 0
-	shatteredDataclass: ShatteredDataclass = dataclasses.field(default=None, init=True) # type: ignore[assignment, reportAssignmentType]
-
-	# ========================================
-	# Source
-	source_astModule = parsePathFilename2astModule(theNumbaFlow.pathFilenameSequential)
-	sourceCountCallable: ast_Identifier = theNumbaFlow.callableSequential
-
-	sourceLogicalPathModuleDataclass: str_nameDOTname = theNumbaFlow.logicalPathModuleDataclass
-	sourceDataclassIdentifier: ast_Identifier = theNumbaFlow.dataclassIdentifier
-	sourceDataclassInstance: ast_Identifier = theNumbaFlow.dataclassInstance
-
-	sourcePathPackage: PurePosixPath | None = theNumbaFlow.pathPackage
-	sourcePackageIdentifier: ast_Identifier | None = theNumbaFlow.packageIdentifier
-
-	# ========================================
-	# Filesystem (names of physical objects)
-	pathPackage: PurePosixPath | None = None
-	pathModule: PurePosixPath | None = PurePosixPath(getPathRootJobDEFAULT())
-	""" `pathModule` will override `pathPackage` and `logicalPathRoot`."""
-	fileExtension: str = theNumbaFlow.fileExtension
-	pathFilenameFoldsTotal: PurePosixPath = dataclasses.field(default=None, init=True) # type: ignore[assignment, reportAssignmentType]
-
-	# ========================================
-	# Logical identifiers (as opposed to physical identifiers)
-	# ========================================
-	packageIdentifier: ast_Identifier | None = None
-	logicalPathRoot: str_nameDOTname | None = None
-	""" `logicalPathRoot` likely corresponds to a physical filesystem directory."""
-	moduleIdentifier: ast_Identifier = dataclasses.field(default=None, init=True) # type: ignore[assignment, reportAssignmentType]
-	countCallable: ast_Identifier = sourceCountCallable
-	dataclassIdentifier: ast_Identifier | None = sourceDataclassIdentifier
-	dataclassInstance: ast_Identifier | None = sourceDataclassInstance
-	logicalPathModuleDataclass: str_nameDOTname | None = sourceLogicalPathModuleDataclass
-
-	# ========================================
-	# Datatypes
-	DatatypeFoldsTotal: TypeAlias = TheDatatypeFoldsTotal
-	DatatypeElephino: TypeAlias = TheDatatypeElephino
-	DatatypeLeavesTotal: TypeAlias = TheDatatypeLeavesTotal
-
-	def _makePathFilename(self,
-			pathRoot: PurePosixPath | None = None,
-			logicalPathINFIX: str_nameDOTname | None = None,
-			filenameStem: str | None = None,
-			fileExtension: str | None = None,
-			) -> PurePosixPath:
-		if pathRoot is None:
-			pathRoot = self.pathPackage or PurePosixPath(Path.cwd())
-		if logicalPathINFIX:
-			whyIsThisStillAThing: list[str] = logicalPathINFIX.split('.')
-			pathRoot = pathRoot.joinpath(*whyIsThisStillAThing)
-		if filenameStem is None:
-			filenameStem = self.moduleIdentifier
-		if fileExtension is None:
-			fileExtension = self.fileExtension
-		filename: str = filenameStem + fileExtension
-		return pathRoot.joinpath(filename)
-
-	@property
-	def pathFilenameModule(self) -> PurePosixPath:
-		if self.pathModule is None:
-			return self._makePathFilename()
-		else:
-			return self._makePathFilename(pathRoot=self.pathModule, logicalPathINFIX=None)
-
-	def __post_init__(self):
-		pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(self.state.mapShape))
-
-		if self.moduleIdentifier is None: # type: ignore
-			self.moduleIdentifier = pathFilenameFoldsTotal.stem
-
-		if self.pathFilenameFoldsTotal is None: # type: ignore
-			self.pathFilenameFoldsTotal = pathFilenameFoldsTotal
-
-		if self.shatteredDataclass is None and self.logicalPathModuleDataclass and self.dataclassIdentifier and self.dataclassInstance: # type: ignore
-			self.shatteredDataclass = shatter_dataclassesDOTdataclass(self.logicalPathModuleDataclass, self.dataclassIdentifier, self.dataclassInstance)
-
-	# ========================================
-	# Fields you probably don't need =================================
-	# Dispatcher =================================
-	sourceDispatcherCallable: ast_Identifier = theNumbaFlow.callableDispatcher
-	dispatcherCallable: ast_Identifier = sourceDispatcherCallable
-	# Parallel counting =================================
-	sourceDataclassInstanceTaskDistribution: ast_Identifier = theNumbaFlow.dataclassInstanceTaskDistribution
-	sourceConcurrencyManagerNamespace: ast_Identifier = theNumbaFlow.concurrencyManagerNamespace
-	sourceConcurrencyManagerIdentifier: ast_Identifier = theNumbaFlow.concurrencyManagerIdentifier
-	dataclassInstanceTaskDistribution: ast_Identifier = sourceDataclassInstanceTaskDistribution
-	concurrencyManagerNamespace: ast_Identifier = sourceConcurrencyManagerNamespace
-	concurrencyManagerIdentifier: ast_Identifier = sourceConcurrencyManagerIdentifier
+# Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
+class be:
+	@staticmethod
+	def Call(node: ast.AST) -> TypeGuard[ast.Call]:
+		return isinstance(node, ast.Call)
+	@staticmethod
+	def Return(node: ast.AST) -> TypeGuard[ast.Return]:
+		return isinstance(node, ast.Return)
 
 def makeNumbaFlow(numbaFlow: RecipeSynthesizeFlow) -> None:
-	# TODO a tool to automatically remove unused variables from the ArgumentsSpecification (return, and returns) _might_ be nice.
-	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-
-	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) # type: ignore
-
-	# 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
-
-	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) # type: ignore
+	"""
+	Transform standard Python algorithm code into optimized Numba implementations.
 
-	# numba decorators =========================================
-	ingredientsParallel = decorateCallableWithNumba(ingredientsParallel)
-	ingredientsSequential = decorateCallableWithNumba(ingredientsSequential)
+	This function implements the complete transformation pipeline 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
 
-	# Module-level transformations ===========================================================
-	ingredientsModuleNumbaUnified = IngredientsModule(ingredientsFunction=listAllIngredientsFunctions, imports=LedgerOfImports(numbaFlow.source_astModule))
+	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)
 
+def getIt(astCallConcurrencyResult: list[ast.Call]) -> Callable[[ast.AST], ast.AST]:
+	def workhorse(node: ast.AST) -> ast.AST:
+		NodeTourist(be.Call, Then.appendTo(astCallConcurrencyResult)).visit(node)
+		return node
+	return workhorse
+
 if __name__ == '__main__':
 	makeNumbaFlow(theNumbaFlow)