mapFolding 0.3.12__py3-none-any.whl → 0.4.0__py3-none-any.whl

mapFolding/someAssemblyRequired/synthesizeNumba.py

@@ -1,637 +1,347 @@
 """I think this module is free of hardcoded values.
 TODO: consolidate the logic in this module."""
-from mapFolding import (
-    computationState,
-    EnumIndices,
-    FREAKOUT,
-    getAlgorithmSource,
-    getFilenameFoldsTotal,
-    getPathFilenameFoldsTotal,
-    getPathJobRootDEFAULT,
-    getPathSyntheticModules,
-    hackSSOTdatatype,
-    indexMy,
-    indexTrack,
-    moduleOfSyntheticModules,
-    myPackageNameIs,
-    ParametersNumba,
-    parametersNumbaDEFAULT,
-    parametersNumbaFailEarly,
-    parametersNumbaSuperJit,
-    parametersNumbaSuperJitParallel,
-    setDatatypeElephino,
-    setDatatypeFoldsTotal,
-    setDatatypeLeavesTotal,
-    setDatatypeModule,
-    Z0Z_getDatatypeModuleScalar,
-    Z0Z_getDecoratorCallable,
-    Z0Z_identifierCountFolds,
-    Z0Z_setDatatypeModuleScalar,
-    Z0Z_setDecoratorCallable,
-)
-from mapFolding.someAssemblyRequired import makeStateJob
-from types import ModuleType
-from typing import Any, Callable, cast, Dict, List, Optional, Sequence, Set, Tuple, Type, Union
-import ast
-import autoflake
-import collections
-import inspect
-import more_itertools
-import numba
-import numpy
-import os
-import pathlib
-import python_minifier
-
-youOughtaKnow = collections.namedtuple('youOughtaKnow', ['callableSynthesized', 'pathFilenameForMe', 'astForCompetentProgrammers'])
-
-class UniversalImportTracker:
-    def __init__(self):
-        self.dictionaryImportFrom = collections.defaultdict(set)
-        self.setImport = set()
-
-    def addAst(self, astImport_: Union[ast.Import, ast.ImportFrom]) -> None:
-        if isinstance(astImport_, ast.Import):
-            for alias in astImport_.names:
-                self.setImport.add(alias.name)
-        elif isinstance(astImport_, ast.ImportFrom):
-            self.dictionaryImportFrom[astImport_.module].update(alias.name for alias in astImport_.names)
-
-    def addImportFromStr(self, module: str, name: str) -> None:
-        self.dictionaryImportFrom[module].add(name)
-
-    def addImportStr(self, name: str) -> None:
-        self.setImport.add(name)
-
-    def makeListAst(self) -> List[Union[ast.ImportFrom, ast.Import]]:
-        listAstImportFrom = [ast.ImportFrom(module=module, names=[ast.alias(name=name, asname=None)], level=0) for module, names in self.dictionaryImportFrom.items() for name in names]
-        listAstImport = [ast.Import(names=[ast.alias(name=name, asname=None)]) for name in self.setImport]
-        return listAstImportFrom + listAstImport
-
-class NodeReplacer(ast.NodeTransformer):
-    """Generic node replacement using configurable predicate and builder."""
-    def __init__(self, findMe: Callable[[ast.AST], bool], nodeReplacementBuilder: Callable[[ast.AST], ast.AST]):
-        self.findMe = findMe
-        self.nodeReplacementBuilder = nodeReplacementBuilder
-
-    def visit(self, node: ast.AST) -> ast.AST:
-        if self.findMe(node):
-            return self.nodeReplacementBuilder(node)
-        return super().visit(node)
-
-class RecursiveInliner(ast.NodeTransformer):
-    """
-    Class RecursiveInliner:
-        A custom AST NodeTransformer designed to recursively inline function calls from a given dictionary
-        of function definitions into the AST. Once a particular function has been inlined, it is marked
-        as completed to avoid repeated inlining. This transformation modifies the AST in-place by substituting
-        eligible function calls with the body of their corresponding function.
-        Attributes:
-            dictionaryFunctions (Dict[str, ast.FunctionDef]):
-                A mapping of function name to its AST definition, used as a source for inlining.
-            callablesCompleted (Set[str]):
-                A set to track function names that have already been inlined to prevent multiple expansions.
-        Methods:
-            inlineFunctionBody(callableTargetName: str) -> Optional[ast.FunctionDef]:
-                Retrieves the AST definition for a given function name from dictionaryFunctions
-                and recursively inlines any function calls within it. Returns the function definition
-                that was inlined or None if the function was already processed.
-            visit_Call(callNode: ast.Call) -> ast.AST:
-                Inspects calls within the AST. If a function call matches one in dictionaryFunctions,
-                it is replaced by the inlined body. If the last statement in the inlined body is a return
-                or an expression, that value or expression is substituted; otherwise, a constant is returned.
-            visit_Expr(node: ast.Expr) -> Union[ast.AST, List[ast.AST]]:
-                Handles expression nodes in the AST. If the expression is a function call from
-                dictionaryFunctions, its statements are expanded in place, effectively inlining
-                the called function's statements into the surrounding context.
-    """
-    def __init__(self, dictionaryFunctions: Dict[str, ast.FunctionDef]):
-        self.dictionaryFunctions = dictionaryFunctions
-        self.callablesCompleted: Set[str] = set()
-
-    def inlineFunctionBody(self, callableTargetName: str) -> Optional[ast.FunctionDef]:
-        if (callableTargetName in self.callablesCompleted):
-            return None
-
-        self.callablesCompleted.add(callableTargetName)
-        inlineDefinition = self.dictionaryFunctions[callableTargetName]
-        for astNode in ast.walk(inlineDefinition):
-            self.visit(astNode)
-        return inlineDefinition
-
-    def visit_Call(self, node: ast.Call) -> ast.AST:
-        callNodeVisited = self.generic_visit(node)
-        if (isinstance(callNodeVisited, ast.Call) and isinstance(callNodeVisited.func, ast.Name) and callNodeVisited.func.id in self.dictionaryFunctions):
-            inlineDefinition = self.inlineFunctionBody(callNodeVisited.func.id)
-            if (inlineDefinition and inlineDefinition.body):
-                statementTerminating = inlineDefinition.body[-1]
-                if (isinstance(statementTerminating, ast.Return) and statementTerminating.value is not None):
-                    return self.visit(statementTerminating.value)
-                elif (isinstance(statementTerminating, ast.Expr) and statementTerminating.value is not None):
-                    return self.visit(statementTerminating.value)
-                return ast.Constant(value=None)
-        return callNodeVisited
-
-    def visit_Expr(self, node: ast.Expr) -> Union[ast.AST, List[ast.AST]]:
-        if (isinstance(node.value, ast.Call)):
-            if (isinstance(node.value.func, ast.Name) and node.value.func.id in self.dictionaryFunctions):
-                inlineDefinition = self.inlineFunctionBody(node.value.func.id)
-                if (inlineDefinition):
-                    return [self.visit(stmt) for stmt in inlineDefinition.body]
-        return self.generic_visit(node)
-
-class UnpackArrays(ast.NodeTransformer):
-    """
-    A class that transforms array accesses using enum indices into local variables.
-
-    This AST transformer identifies array accesses using enum indices and replaces them
-    with local variables, adding initialization statements at the start of functions.
-
-    Parameters:
-        enumIndexClass (Type[EnumIndices]): The enum class used for array indexing
-        arrayName (str): The name of the array being accessed
-
-    Attributes:
-        enumIndexClass (Type[EnumIndices]): Stored enum class for index lookups
-        arrayName (str): Name of the array being transformed
-        substitutions (dict): Tracks variable substitutions and their original nodes
-
-    The transformer handles two main cases:
-    1. Scalar array access - array[EnumIndices.MEMBER]
-    2. Array slice access - array[EnumIndices.MEMBER, other_indices...]
-    For each identified access pattern, it:
-    1. Creates a local variable named after the enum member
-    2. Adds initialization code at function start
-    3. Replaces original array access with the local variable
-    """
-
-    def __init__(self, enumIndexClass: Type[EnumIndices], arrayName: str):
-        self.enumIndexClass = enumIndexClass
-        self.arrayName = arrayName
-        self.substitutions = {}
-
-    def extract_member_name(self, node: ast.AST) -> Optional[str]:
-        """Recursively extract enum member name from any node in the AST."""
-        if isinstance(node, ast.Attribute) and node.attr == 'value':
-            innerAttribute = node.value
-            while isinstance(innerAttribute, ast.Attribute):
-                if (isinstance(innerAttribute.value, ast.Name) and innerAttribute.value.id == self.enumIndexClass.__name__):
-                    return innerAttribute.attr
-                innerAttribute = innerAttribute.value
-        return None
-
-    def transform_slice_element(self, node: ast.AST) -> ast.AST:
-        """Transform any enum references within a slice element."""
-        if isinstance(node, ast.Subscript):
-            if isinstance(node.slice, ast.Attribute):
-                member_name = self.extract_member_name(node.slice)
-                if member_name:
-                    return ast.Name(id=member_name, ctx=node.ctx)
-            elif isinstance(node, ast.Tuple):
-                # Handle tuple slices by transforming each element
-                return ast.Tuple(elts=cast(List[ast.expr], [self.transform_slice_element(elt) for elt in node.elts]), ctx=node.ctx)
-        elif isinstance(node, ast.Attribute):
-            member_name = self.extract_member_name(node)
-            if member_name:
-                return ast.Name(id=member_name, ctx=ast.Load())
-        return node
-
-    def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
-        # Recursively visit any nested subscripts in value or slice
-        node.value = self.visit(node.value)
-        node.slice = self.visit(node.slice)
-        # If node.value is not our arrayName, just return node
-        if not (isinstance(node.value, ast.Name) and node.value.id == self.arrayName):
-            return node
-
-        # Handle scalar array access
-        if isinstance(node.slice, ast.Attribute):
-            memberName = self.extract_member_name(node.slice)
-            if memberName:
-                self.substitutions[memberName] = ('scalar', node)
-                return ast.Name(id=memberName, ctx=ast.Load())
-
-        # Handle array slice access
-        if isinstance(node.slice, ast.Tuple) and node.slice.elts:
-            firstElement = node.slice.elts[0]
-            memberName = self.extract_member_name(firstElement)
-            sliceRemainder = [self.visit(elem) for elem in node.slice.elts[1:]]
-            if memberName:
-                self.substitutions[memberName] = ('array', node)
-                if len(sliceRemainder) == 0:
-                    return ast.Name(id=memberName, ctx=ast.Load())
-                return ast.Subscript(value=ast.Name(id=memberName, ctx=ast.Load()), slice=ast.Tuple(elts=sliceRemainder, ctx=ast.Load()) if len(sliceRemainder) > 1 else sliceRemainder[0], ctx=ast.Load())
-
-        # If single-element tuple, unwrap
-        if isinstance(node.slice, ast.Tuple) and len(node.slice.elts) == 1:
-            node.slice = node.slice.elts[0]
-
-        return node
-
-    def visit_FunctionDef(self, node: ast.FunctionDef) -> ast.FunctionDef:
-        node = cast(ast.FunctionDef, self.generic_visit(node))
-
-        initializations = []
-        for name, (kind, original_node) in self.substitutions.items():
-            if kind == 'scalar':
-                initializations.append(ast.Assign(targets=[ast.Name(id=name, ctx=ast.Store())], value=original_node))
-            else:  # array
-                initializations.append(
-                    ast.Assign(
-                        targets=[ast.Name(id=name, ctx=ast.Store())],
-                        value=ast.Subscript(value=ast.Name(id=self.arrayName, ctx=ast.Load()),
-                            slice=ast.Attribute(value=ast.Attribute(
-                                    value=ast.Name(id=self.enumIndexClass.__name__, ctx=ast.Load()),
-                                    attr=name, ctx=ast.Load()), attr='value', ctx=ast.Load()), ctx=ast.Load())))
-
-        node.body = initializations + node.body
-        return node
-
-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.
-    for decoratorItem in astCallable.decorator_list.copy():
-        import warnings
-        astCallable.decorator_list.remove(decoratorItem)
-        warnings.warn(f"Removed decorator {ast.unparse(decoratorItem)} from {astCallable.name}")
-    return astCallable
-def isThisNodeNumbaJitCall(node: ast.AST) -> bool:
-    return (isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute) and node.func.attr == Z0Z_getDecoratorCallable())
-def isThisNodeJitCall(node: ast.AST) -> bool:
-    return (isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id == Z0Z_getDecoratorCallable())
-def isThisNodeNumbaJitDecorator(node: ast.AST) -> bool:
-    return isThisNodeNumbaJitCall(node) or isThisNodeJitCall(node)
-def Z0Z_generalizeThis(FunctionDefTarget: ast.FunctionDef, parametersNumba: Optional[ParametersNumba]=None) -> Tuple[ast.FunctionDef, ParametersNumba | None]:
-    def recycleParametersNumba(decorator: ast.Call) -> Dict[str, Any]:
-        parametersNumbaExtracted: Dict[str, Any] = {}
-        for keywordItem in decorator.keywords:
-            if isinstance(keywordItem.value, ast.Constant) and keywordItem.arg is not None:
-                parametersNumbaExtracted[keywordItem.arg] = keywordItem.value.value
-        return parametersNumbaExtracted
-
-    for decorator in FunctionDefTarget.decorator_list.copy():
-        if isThisNodeNumbaJitDecorator(decorator):
-            decorator = cast(ast.Call, decorator)
-            if parametersNumba is None:
-                parametersNumbaSherpa = recycleParametersNumba(decorator)
-                if (HunterIsSureThereAreBetterWaysToDoThis := True):
-                    if parametersNumbaSherpa:
-                        parametersNumba = cast(ParametersNumba, parametersNumbaSherpa)
-        FunctionDefTarget.decorator_list.remove(decorator)
-
-    return FunctionDefTarget, parametersNumba
-
-def decorateCallableWithNumba(FunctionDefTarget: ast.FunctionDef, allImports: UniversalImportTracker, parametersNumba: Optional[ParametersNumba]=None) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
-    datatypeModuleDecorator = Z0Z_getDatatypeModuleScalar()
-    def make_arg4parameter(signatureElement: ast.arg):
-        if isinstance(signatureElement.annotation, ast.Subscript) and isinstance(signatureElement.annotation.slice, ast.Tuple):
-            annotationShape = signatureElement.annotation.slice.elts[0]
-            if isinstance(annotationShape, ast.Subscript) and isinstance(annotationShape.slice, ast.Tuple):
-                shapeAsListSlices: Sequence[ast.expr] = [ast.Slice() for axis in range(len(annotationShape.slice.elts))]
-                shapeAsListSlices[-1] = ast.Slice(step=ast.Constant(value=1))
-                shapeAST = ast.Tuple(elts=list(shapeAsListSlices), ctx=ast.Load())
-            else:
-                shapeAST = ast.Slice(step=ast.Constant(value=1))
-
-            annotationDtype = signatureElement.annotation.slice.elts[1]
-            if (isinstance(annotationDtype, ast.Subscript) and isinstance(annotationDtype.slice, ast.Attribute)):
-                datatypeAST = annotationDtype.slice.attr
-            else:
-                datatypeAST = None
-
-            ndarrayName = signatureElement.arg
-            Z0Z_hacky_dtype = hackSSOTdatatype(ndarrayName)
-            datatype_attr = datatypeAST or Z0Z_hacky_dtype
-            allImports.addImportFromStr(datatypeModuleDecorator, datatype_attr)
-            datatypeNumba = ast.Name(id=datatype_attr, ctx=ast.Load())
-
-            return ast.Subscript(value=datatypeNumba, slice=shapeAST, ctx=ast.Load())
-
-    list_argsDecorator: Sequence[ast.expr] = []
-
-    list_arg4signature_or_function: Sequence[ast.expr] = []
-    for parameter in FunctionDefTarget.args.args:
-        signatureElement = make_arg4parameter(parameter)
-        if signatureElement:
-            list_arg4signature_or_function.append(signatureElement)
-
-    if FunctionDefTarget.returns and isinstance(FunctionDefTarget.returns, ast.Name):
-        theReturn: ast.Name = FunctionDefTarget.returns
-        list_argsDecorator = [cast(ast.expr, ast.Call(func=ast.Name(id=theReturn.id, ctx=ast.Load())
-                            , args=list_arg4signature_or_function if list_arg4signature_or_function else [] , keywords=[] ) )]
-    elif list_arg4signature_or_function:
-        list_argsDecorator = [cast(ast.expr, ast.Tuple(elts=list_arg4signature_or_function, ctx=ast.Load()))]
-
-    FunctionDefTarget, parametersNumba = Z0Z_generalizeThis(FunctionDefTarget, parametersNumba)
-    FunctionDefTarget = Z0Z_UnhandledDecorators(FunctionDefTarget)
-    if parametersNumba is None:
-        parametersNumba = parametersNumbaDEFAULT
-    listDecoratorKeywords = [ast.keyword(arg=parameterName, value=ast.Constant(value=parameterValue)) for parameterName, parameterValue in parametersNumba.items()]
-
-    decoratorModule = Z0Z_getDatatypeModuleScalar()
-    decoratorCallable = Z0Z_getDecoratorCallable()
-    allImports.addImportFromStr(decoratorModule, decoratorCallable)
-    astDecorator = ast.Call(
-        func=ast.Name(id=decoratorCallable, ctx=ast.Load())
-        , args=list_argsDecorator if list_argsDecorator else []
-        , keywords=listDecoratorKeywords)
-
-    FunctionDefTarget.decorator_list = [astDecorator]
-    return FunctionDefTarget, allImports
-
-def makeDecoratorJobNumba(FunctionDefTarget: ast.FunctionDef, allImports: UniversalImportTracker, parametersNumba: Optional[ParametersNumba]=None) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
-    decoratorCallable = Z0Z_getDecoratorCallable()
-    def convertToPlainJit(node: ast.Call) -> ast.Call:
-        node.func = ast.Name(id=decoratorCallable, ctx=ast.Load())
-        return node
-
-    FunctionDefTarget, parametersNumba = Z0Z_generalizeThis(FunctionDefTarget, parametersNumba)
-
-    FunctionDefTarget, allImports = decorateCallableWithNumba(FunctionDefTarget, allImports, parametersNumba)
-    if isThisNodeNumbaJitCall(FunctionDefTarget.decorator_list[0]):
-        FunctionDefTarget.decorator_list[0] = convertToPlainJit(cast(ast.Call, FunctionDefTarget.decorator_list[0]))
-
-    return FunctionDefTarget, allImports
-
-def inlineOneCallable(pythonSource: str, callableTarget: str, parametersNumba: Optional[ParametersNumba]=None, unpackArrays: Optional[bool]=False) -> str:
-    astModule: ast.Module = ast.parse(pythonSource, type_comments=True)
-    allImports = UniversalImportTracker()
-
-    for statement in astModule.body:
-        if isinstance(statement, (ast.Import, ast.ImportFrom)):
-            allImports.addAst(statement)
-
-    dictionaryFunctionDef = {statement.name: statement for statement in astModule.body if isinstance(statement, ast.FunctionDef)}
-    callableInlinerWorkhorse = RecursiveInliner(dictionaryFunctionDef)
-    FunctionDefTarget = callableInlinerWorkhorse.inlineFunctionBody(callableTarget)
-
-    if not FunctionDefTarget:
-        raise FREAKOUT
-
-    ast.fix_missing_locations(FunctionDefTarget)
-
-    FunctionDefTarget, allImports = decorateCallableWithNumba(FunctionDefTarget, allImports, parametersNumba)
-
-    if unpackArrays:
-        for tupleUnpack in [(indexMy, 'my'), (indexTrack, 'track')]:
-            unpacker = UnpackArrays(*tupleUnpack)
-            FunctionDefTarget = cast(ast.FunctionDef, unpacker.visit(FunctionDefTarget))
-            ast.fix_missing_locations(FunctionDefTarget)
-
-    moduleAST = ast.Module(body=cast(List[ast.stmt], allImports.makeListAst() + [FunctionDefTarget]), type_ignores=[])
-    ast.fix_missing_locations(moduleAST)
-    moduleSource = ast.unparse(moduleAST)
-    return moduleSource
-
-def makeDispatcherNumba(pythonSource: str, callableTarget: str, listStuffYouOughtaKnow: List[youOughtaKnow]) -> str:
-    astSource = ast.parse(pythonSource)
-    allImports = UniversalImportTracker()
-
-    for statement in astSource.body:
-        if isinstance(statement, (ast.Import, ast.ImportFrom)):
-            allImports.addAst(statement)
-
-    for stuff in listStuffYouOughtaKnow:
-        statement = stuff.astForCompetentProgrammers
-        if isinstance(statement, (ast.Import, ast.ImportFrom)):
-            allImports.addAst(statement)
-
-    FunctionDefTarget = next((node for node in astSource.body if isinstance(node, ast.FunctionDef) and node.name == callableTarget), None)
-
-    if not FunctionDefTarget:
-        raise ValueError(f"Could not find function {callableTarget} in source code")
-
-    FunctionDefTarget, allImports = decorateCallableWithNumba(FunctionDefTarget, allImports, parametersNumbaFailEarly)
-
-    astModule = ast.Module(body=cast(List[ast.stmt], allImports.makeListAst() + [FunctionDefTarget]), type_ignores=[])
-
-    ast.fix_missing_locations(astModule)
-    return ast.unparse(astModule)
-
-def makeStrRLEcompacted(arrayTarget: numpy.ndarray, identifierName: Optional[str]=None) -> str:
-    """Converts a NumPy array into a compressed string representation using run-length encoding (RLE).
-
-    This function takes a NumPy array and converts it into an optimized string representation by:
-    1. Compressing consecutive sequences of numbers into range objects
-    2. Minimizing repeated zeros using array multiplication syntax
-    3. Converting the result into a valid Python array initialization statement
-
-    Parameters:
-        arrayTarget (numpy.ndarray): The input NumPy array to be converted
-        identifierName (str): The variable name to use in the output string
-
-    Returns:
-        str: A string containing Python code that recreates the input array in compressed form.
-            Format: "{identifierName} = numpy.array({compressed_data}, dtype=numpy.{dtype})"
-    """
-
-    def compressRangesNDArrayNoFlatten(arraySlice):
-        if isinstance(arraySlice, numpy.ndarray) and arraySlice.ndim > 1:
-            return [compressRangesNDArrayNoFlatten(arraySlice[index]) for index in range(arraySlice.shape[0])]
-        elif isinstance(arraySlice, numpy.ndarray) and arraySlice.ndim == 1:
-            listWithRanges = []
-            for group in more_itertools.consecutive_groups(arraySlice.tolist()):
-                ImaSerious = list(group)
-                if len(ImaSerious) <= 4:
-                    listWithRanges += ImaSerious
-                else:
-                    ImaRange = [range(ImaSerious[0], ImaSerious[-1] + 1)]
-                    listWithRanges += ImaRange
-            return listWithRanges
-        return arraySlice
-
-    arrayAsNestedLists = compressRangesNDArrayNoFlatten(arrayTarget)
-
-    stringMinimized = python_minifier.minify(str(arrayAsNestedLists))
-    commaZeroMaximum = arrayTarget.shape[-1] - 1
-    stringMinimized = stringMinimized.replace('[0' + ',0'*commaZeroMaximum + ']', '[0]*'+str(commaZeroMaximum+1))
-    for countZeros in range(commaZeroMaximum, 2, -1):
-        stringMinimized = stringMinimized.replace(',0'*countZeros + ']', ']+[0]*'+str(countZeros))
-
-    stringMinimized = stringMinimized.replace('range', '*range')
-
-    if identifierName:
-        return f"{identifierName} = array({stringMinimized}, dtype={arrayTarget.dtype})"
-    return stringMinimized
-
-def moveArrayTo_body(FunctionDefTarget: ast.FunctionDef, astArg: ast.arg, argData: numpy.ndarray, allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
-    arrayType = type(argData)
-    moduleConstructor = arrayType.__module__
-    constructorName = arrayType.__name__
-    # NOTE hack
-    constructorName = constructorName.replace('ndarray', 'array')
-    argData_dtype: numpy.dtype = argData.dtype
-    argData_dtypeName = argData.dtype.name
-
-    allImports.addImportFromStr(moduleConstructor, constructorName)
-    allImports.addImportFromStr(moduleConstructor, argData_dtypeName)
-
-    onlyDataRLE = makeStrRLEcompacted(argData)
-    astStatement = cast(ast.Expr, ast.parse(onlyDataRLE).body[0])
-    dataAst = astStatement.value
-
-    arrayCall = ast.Call(
-        func=ast.Name(id=constructorName, ctx=ast.Load())
-        , args=[dataAst]
-        , keywords=[ast.keyword(arg='dtype' , value=ast.Name(id=argData_dtypeName , ctx=ast.Load()) ) ] )
-
-    assignment = ast.Assign( targets=[ast.Name(id=astArg.arg, ctx=ast.Store())], value=arrayCall )
-    FunctionDefTarget.body.insert(0, assignment)
-    FunctionDefTarget.args.args.remove(astArg)
-
-    return FunctionDefTarget, allImports
-
-def evaluateArrayIn_body(FunctionDefTarget: ast.FunctionDef, astArg: ast.arg, argData: numpy.ndarray, allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
-    arrayType = type(argData)
-    moduleConstructor = arrayType.__module__
-    constructorName = arrayType.__name__
-    # NOTE hack
-    constructorName = constructorName.replace('ndarray', 'array')
-    allImports.addImportFromStr(moduleConstructor, constructorName)
-
-    for stmt in FunctionDefTarget.body.copy():
-        if isinstance(stmt, ast.Assign):
-            if isinstance(stmt.targets[0], ast.Name) and isinstance(stmt.value, ast.Subscript):
-                astAssignee: ast.Name = stmt.targets[0]
-                argData_dtypeName = hackSSOTdatatype(astAssignee.id)
-                allImports.addImportFromStr(moduleConstructor, argData_dtypeName)
-                astSubscript: ast.Subscript = stmt.value
-                if isinstance(astSubscript.value, ast.Name) and astSubscript.value.id == astArg.arg and isinstance(astSubscript.slice, ast.Attribute):
-                    indexAs_astAttribute: ast.Attribute = astSubscript.slice
-                    indexAsStr = ast.unparse(indexAs_astAttribute)
-                    argDataSlice = argData[eval(indexAsStr)]
-
-                    onlyDataRLE = makeStrRLEcompacted(argDataSlice)
-                    astStatement = cast(ast.Expr, ast.parse(onlyDataRLE).body[0])
-                    dataAst = astStatement.value
-
-                    arrayCall = ast.Call(
-                        func=ast.Name(id=constructorName, ctx=ast.Load()) , args=[dataAst]
-                        , keywords=[ast.keyword(arg='dtype', value=ast.Name(id=argData_dtypeName, ctx=ast.Load()) ) ] )
-
-                    assignment = ast.Assign( targets=[astAssignee], value=arrayCall )
-                    FunctionDefTarget.body.insert(0, assignment)
-                    FunctionDefTarget.body.remove(stmt)
-
-    FunctionDefTarget.args.args.remove(astArg)
-    return FunctionDefTarget, allImports
-
-def evaluate_argIn_body(FunctionDefTarget: ast.FunctionDef, astArg: ast.arg, argData: numpy.ndarray, Z0Z_listChaff: List[str], allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
-    moduleConstructor = Z0Z_getDatatypeModuleScalar()
-    for stmt in FunctionDefTarget.body.copy():
-        if isinstance(stmt, ast.Assign):
-            if isinstance(stmt.targets[0], ast.Name) and isinstance(stmt.value, ast.Subscript):
-                astAssignee: ast.Name = stmt.targets[0]
-                argData_dtypeName = hackSSOTdatatype(astAssignee.id)
-                allImports.addImportFromStr(moduleConstructor, argData_dtypeName)
-                astSubscript: ast.Subscript = stmt.value
-                if isinstance(astSubscript.value, ast.Name) and astSubscript.value.id == astArg.arg and isinstance(astSubscript.slice, ast.Attribute):
-                    indexAs_astAttribute: ast.Attribute = astSubscript.slice
-                    indexAsStr = ast.unparse(indexAs_astAttribute)
-                    argDataSlice: int = argData[eval(indexAsStr)].item()
-                    astCall = ast.Call(func=ast.Name(id=argData_dtypeName, ctx=ast.Load()) , args=[ast.Constant(value=argDataSlice)], keywords=[])
-                    assignment = ast.Assign(targets=[astAssignee], value=astCall)
-                    if astAssignee.id not in Z0Z_listChaff:
-                        FunctionDefTarget.body.insert(0, assignment)
-                    FunctionDefTarget.body.remove(stmt)
-    FunctionDefTarget.args.args.remove(astArg)
-    return FunctionDefTarget, allImports
-
-def evaluateAnnAssignIn_body(FunctionDefTarget: ast.FunctionDef, allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
-    moduleConstructor = Z0Z_getDatatypeModuleScalar()
-    for stmt in FunctionDefTarget.body.copy():
-        if isinstance(stmt, ast.AnnAssign):
-            if isinstance(stmt.target, ast.Name) and isinstance(stmt.value, ast.Constant):
-                astAssignee: ast.Name = stmt.target
-                argData_dtypeName = hackSSOTdatatype(astAssignee.id)
-                allImports.addImportFromStr(moduleConstructor, argData_dtypeName)
-                astCall = ast.Call(func=ast.Name(id=argData_dtypeName, ctx=ast.Load()) , args=[stmt.value], keywords=[])
-                assignment = ast.Assign(targets=[astAssignee], value=astCall)
-                FunctionDefTarget.body.insert(0, assignment)
-                FunctionDefTarget.body.remove(stmt)
-    return FunctionDefTarget, allImports
-
-def removeIdentifierFrom_body(FunctionDefTarget: ast.FunctionDef, astArg: ast.arg) -> ast.FunctionDef:
-    for stmt in FunctionDefTarget.body.copy():
-        if isinstance(stmt, ast.Assign):
-            if isinstance(stmt.targets[0], ast.Subscript) and isinstance(stmt.targets[0].value, ast.Name):
-                if stmt.targets[0].value.id == astArg.arg:
-                    FunctionDefTarget.body.remove(stmt)
-    FunctionDefTarget.args.args.remove(astArg)
-    return FunctionDefTarget
-
-def astObjectToAstConstant(FunctionDefTarget: ast.FunctionDef, object: str, value: int) -> ast.FunctionDef:
-    """
-    Replaces nodes in astFunction matching the AST of the string `object`
-    with a constant node holding the provided value.
-    """
-    targetExpression = ast.parse(object, mode='eval').body
-    targetDump = ast.dump(targetExpression, annotate_fields=False)
-
-    def findNode(node: ast.AST) -> bool:
-        return ast.dump(node, annotate_fields=False) == targetDump
-
-    def replaceWithConstant(node: ast.AST) -> ast.AST:
-        return ast.copy_location(ast.Constant(value=value), node)
-
-    transformer = NodeReplacer(findNode, replaceWithConstant)
-    newFunction = cast(ast.FunctionDef, transformer.visit(FunctionDefTarget))
-    ast.fix_missing_locations(newFunction)
-    return newFunction
-
-def astNameToAstConstant(FunctionDefTarget: ast.FunctionDef, name: str, value: int) -> ast.FunctionDef:
-    def findName(node: ast.AST) -> bool:
-        return isinstance(node, ast.Name) and node.id == name
-
-    def replaceWithConstant(node: ast.AST) -> ast.AST:
-        return ast.copy_location(ast.Constant(value=value), node)
-
-    return cast(ast.FunctionDef, NodeReplacer(findName, replaceWithConstant).visit(FunctionDefTarget))
-
-def makeLauncherJobNumba(callableTarget: str, pathFilenameFoldsTotal: pathlib.Path) -> ast.Module:
-    linesLaunch = f"""
+from mapFolding.someAssemblyRequired.synthesizeNumbaGeneralized import *
+
+def insertArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arrayTarget: numpy.ndarray, allImports: UniversalImportTracker, unrollSlices: Optional[int]=None) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+	arrayType = type(arrayTarget)
+	moduleConstructor = arrayType.__module__
+	constructorName = arrayType.__name__
+	# NOTE hack
+	constructorName = constructorName.replace('ndarray', 'array')
+	argData_dtype: numpy.dtype = arrayTarget.dtype
+	argData_dtypeName = arrayTarget.dtype.name
+
+	allImports.addImportFromStr(moduleConstructor, constructorName)
+	allImports.addImportFromStr(moduleConstructor, argData_dtypeName)
+
+	def insertAssign(assignee: str, arraySlice: numpy.ndarray) -> None:
+		nonlocal FunctionDefTarget
+		onlyDataRLE = makeStrRLEcompacted(arraySlice) #NOTE
+		astStatement = cast(ast.Expr, ast.parse(onlyDataRLE).body[0])
+		dataAst = astStatement.value
+
+		arrayCall = Then.make_astCall(name=constructorName, args=[dataAst], dictionaryKeywords={'dtype': ast.Name(id=argData_dtypeName, ctx=ast.Load())})
+
+		assignment = ast.Assign(targets=[ast.Name(id=assignee, ctx=ast.Store())], value=arrayCall)#NOTE
+		FunctionDefTarget.body.insert(0, assignment)
+
+	if not unrollSlices:
+		insertAssign(identifier, arrayTarget)
+	else:
+		for index, arraySlice in enumerate(arrayTarget):
+			insertAssign(f"{identifier}_{index}", arraySlice)
+
+	return FunctionDefTarget, allImports
+
+def findAndReplaceArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arrayTarget: numpy.ndarray, allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+	arrayType = type(arrayTarget)
+	moduleConstructor = arrayType.__module__
+	constructorName = arrayType.__name__
+	# NOTE hack
+	constructorName = constructorName.replace('ndarray', 'array')
+	allImports.addImportFromStr(moduleConstructor, constructorName)
+
+	for stmt in FunctionDefTarget.body.copy():
+		if isinstance(stmt, ast.Assign):
+			if isinstance(stmt.targets[0], ast.Name) and isinstance(stmt.value, ast.Subscript):
+				astAssignee: ast.Name = stmt.targets[0]
+				argData_dtypeName = hackSSOTdatatype(astAssignee.id)
+				allImports.addImportFromStr(moduleConstructor, argData_dtypeName)
+				astSubscript: ast.Subscript = stmt.value
+				if isinstance(astSubscript.value, ast.Name) and astSubscript.value.id == identifier and isinstance(astSubscript.slice, ast.Attribute):
+					indexAs_astAttribute: ast.Attribute = astSubscript.slice
+					indexAsStr = ast.unparse(indexAs_astAttribute)
+					argDataSlice = arrayTarget[eval(indexAsStr)]
+
+					onlyDataRLE = makeStrRLEcompacted(argDataSlice)
+					astStatement = cast(ast.Expr, ast.parse(onlyDataRLE).body[0])
+					dataAst = astStatement.value
+
+					arrayCall = Then.make_astCall(name=constructorName, args=[dataAst], dictionaryKeywords={'dtype': ast.Name(id=argData_dtypeName, ctx=ast.Load())})
+
+					assignment = ast.Assign( targets=[astAssignee], value=arrayCall )
+					FunctionDefTarget.body.insert(0, assignment)
+					FunctionDefTarget.body.remove(stmt)
+	return FunctionDefTarget, allImports
+
+def findAndReplaceArraySubscriptIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arrayTarget: numpy.ndarray, Z0Z_listChaff: List[str], allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+	moduleConstructor = Z0Z_getDatatypeModuleScalar()
+	for stmt in FunctionDefTarget.body.copy():
+		if isinstance(stmt, ast.Assign):
+			if isinstance(stmt.targets[0], ast.Name) and isinstance(stmt.value, ast.Subscript):
+				astAssignee: ast.Name = stmt.targets[0]
+				argData_dtypeName = hackSSOTdatatype(astAssignee.id)
+				allImports.addImportFromStr(moduleConstructor, argData_dtypeName)
+				astSubscript: ast.Subscript = stmt.value
+				if isinstance(astSubscript.value, ast.Name) and astSubscript.value.id == identifier and isinstance(astSubscript.slice, ast.Attribute):
+					indexAs_astAttribute: ast.Attribute = astSubscript.slice
+					indexAsStr = ast.unparse(indexAs_astAttribute)
+					argDataSlice: int = arrayTarget[eval(indexAsStr)].item()
+					astCall = ast.Call(func=ast.Name(id=argData_dtypeName, ctx=ast.Load()) , args=[ast.Constant(value=argDataSlice)], keywords=[])
+					assignment = ast.Assign(targets=[astAssignee], value=astCall)
+					if astAssignee.id not in Z0Z_listChaff:
+						FunctionDefTarget.body.insert(0, assignment)
+					FunctionDefTarget.body.remove(stmt)
+	return FunctionDefTarget, allImports
+
+def removeAssignTargetFrom_body(FunctionDefTarget: ast.FunctionDef, identifier: str) -> ast.FunctionDef:
+	# Remove assignment nodes where the target is either a Subscript referencing `identifier` or satisfies ifThis.nameIs(identifier).
+	def predicate(astNode: ast.AST) -> bool:
+		if not isinstance(astNode, ast.Assign) or not astNode.targets:
+			return False
+		targetNode = astNode.targets[0]
+		return (isinstance(targetNode, ast.Subscript) and isinstance(targetNode.value, ast.Name) and targetNode.value.id == identifier) or ifThis.nameIs(identifier)(targetNode)
+	def replacementBuilder(astNode: ast.AST) -> Optional[ast.stmt]:
+		# Returning None removes the node.
+		return None
+	FunctionDefSherpa = NodeReplacer(predicate, replacementBuilder).visit(FunctionDefTarget)
+	if not FunctionDefSherpa:
+		raise FREAKOUT("Dude, where's my function?")
+	else:
+		FunctionDefTarget = cast(ast.FunctionDef, FunctionDefSherpa)
+	ast.fix_missing_locations(FunctionDefTarget)
+	return FunctionDefTarget
+
+def findAndReplaceAnnAssignIn_body(FunctionDefTarget: ast.FunctionDef, allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+	moduleConstructor = Z0Z_getDatatypeModuleScalar()
+	for stmt in FunctionDefTarget.body.copy():
+		if isinstance(stmt, ast.AnnAssign):
+			if isinstance(stmt.target, ast.Name) and isinstance(stmt.value, ast.Constant):
+				astAssignee: ast.Name = stmt.target
+				argData_dtypeName = hackSSOTdatatype(astAssignee.id)
+				allImports.addImportFromStr(moduleConstructor, argData_dtypeName)
+				astCall = ast.Call(func=ast.Name(id=argData_dtypeName, ctx=ast.Load()) , args=[stmt.value], keywords=[])
+				assignment = ast.Assign(targets=[astAssignee], value=astCall)
+				FunctionDefTarget.body.insert(0, assignment)
+				FunctionDefTarget.body.remove(stmt)
+	return FunctionDefTarget, allImports
+
+def findThingyReplaceWithConstantIn_body(FunctionDefTarget: ast.FunctionDef, object: str, value: int) -> ast.FunctionDef:
+	"""
+	Replaces nodes in astFunction matching the AST of the string `object`
+	with a constant node holding the provided value.
+	"""
+	targetExpression = ast.parse(object, mode='eval').body
+	targetDump = ast.dump(targetExpression, annotate_fields=False)
+
+	def findNode(node: ast.AST) -> bool:
+		return ast.dump(node, annotate_fields=False) == targetDump
+
+	def replaceWithConstant(node: ast.AST) -> ast.AST:
+		return ast.copy_location(ast.Constant(value=value), node)
+
+	transformer = NodeReplacer(findNode, replaceWithConstant)
+	newFunction = cast(ast.FunctionDef, transformer.visit(FunctionDefTarget))
+	ast.fix_missing_locations(newFunction)
+	return newFunction
+
+def findAstNameReplaceWithConstantIn_body(FunctionDefTarget: ast.FunctionDef, name: str, value: int) -> ast.FunctionDef:
+	def findName(node: ast.AST) -> bool:
+		return isinstance(node, ast.Name) and node.id == name
+
+	def replaceWithConstant(node: ast.AST) -> ast.AST:
+		return ast.copy_location(ast.Constant(value=value), node)
+
+	return cast(ast.FunctionDef, NodeReplacer(findName, replaceWithConstant).visit(FunctionDefTarget))
+
+def insertReturnStatementIn_body(FunctionDefTarget: ast.FunctionDef, arrayTarget: numpy.ndarray, allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+	"""Add multiplication and return statement to function, properly constructing AST nodes."""
+	# Create AST for multiplication operation
+	multiplicand = Z0Z_identifierCountFolds
+	datatype = hackSSOTdatatype(multiplicand)
+	multiplyOperation = ast.BinOp(
+		left=ast.Name(id=multiplicand, ctx=ast.Load()),
+		op=ast.Mult(), right=ast.Constant(value=int(arrayTarget[-1])))
+
+	returnStatement = ast.Return(value=multiplyOperation)
+
+	datatypeModuleScalar = Z0Z_getDatatypeModuleScalar()
+	allImports.addImportFromStr(datatypeModuleScalar, datatype)
+
+	FunctionDefTarget.body.append(returnStatement)
+
+	return FunctionDefTarget, allImports
+
+def findAndReplaceWhileLoopIn_body(FunctionDefTarget: ast.FunctionDef, iteratorName: str, iterationsTotal: int) -> Any:
+	"""
+	Unroll all nested while loops matching the condition that their test uses `iteratorName`.
+	"""
+	# Helper transformer to replace iterator occurrences with a constant.
+	class ReplaceIterator(ast.NodeTransformer):
+		def __init__(self, iteratorName: str, constantValue: int) -> None:
+			super().__init__()
+			self.iteratorName = iteratorName
+			self.constantValue = constantValue
+
+		def visit_Name(self, node: ast.Name) -> ast.AST:
+			if node.id == self.iteratorName:
+				return ast.copy_location(ast.Constant(value=self.constantValue), node)
+			return self.generic_visit(node)
+
+	# NodeTransformer that finds while loops (even if deeply nested) and unrolls them.
+	class WhileLoopUnroller(ast.NodeTransformer):
+		def __init__(self, iteratorName: str, iterationsTotal: int) -> None:
+			super().__init__()
+			self.iteratorName = iteratorName
+			self.iterationsTotal = iterationsTotal
+
+		def visit_While(self, node: ast.While) -> List[ast.stmt]:
+				# Check if the while loop's test uses the iterator.
+			if isinstance(node.test, ast.Compare) and ifThis.nameIs(self.iteratorName)(node.test.left):
+				# Recurse the while loop body and remove AugAssign that increments the iterator.
+				cleanBodyStatements: List[ast.stmt] = []
+				for loopStatement in node.body:
+					# Recursively visit nested statements.
+					visitedStatement = self.visit(loopStatement)
+					# Remove direct AugAssign: iterator += 1.
+					if (isinstance(loopStatement, ast.AugAssign) and
+						isinstance(loopStatement.target, ast.Name) and
+						loopStatement.target.id == self.iteratorName and
+						isinstance(loopStatement.op, ast.Add) and
+						isinstance(loopStatement.value, ast.Constant) and
+						loopStatement.value.value == 1):
+						continue
+					cleanBodyStatements.append(visitedStatement)
+
+				newStatements: List[ast.stmt] = []
+				# Unroll using the filtered body.
+				for iterationIndex in range(self.iterationsTotal):
+					for loopStatement in cleanBodyStatements:
+						copiedStatement = copy.deepcopy(loopStatement)
+						replacer = ReplaceIterator(self.iteratorName, iterationIndex)
+						newStatement = replacer.visit(copiedStatement)
+						ast.fix_missing_locations(newStatement)
+						newStatements.append(newStatement)
+				# Optionally, process the orelse block.
+				if node.orelse:
+					for elseStmt in node.orelse:
+						visitedElse = self.visit(elseStmt)
+						if isinstance(visitedElse, list):
+							newStatements.extend(visitedElse)
+						else:
+							newStatements.append(visitedElse)
+				return newStatements
+			return [cast(ast.stmt, self.generic_visit(node))]
+
+	newFunctionDef = WhileLoopUnroller(iteratorName, iterationsTotal).visit(FunctionDefTarget)
+	ast.fix_missing_locations(newFunctionDef)
+	return newFunctionDef
+
+def makeLauncherBasicJobNumba(callableTarget: str, pathFilenameFoldsTotal: pathlib.Path) -> ast.Module:
+	linesLaunch = f"""
 if __name__ == '__main__':
-    import time
-    timeStart = time.perf_counter()
-    foldsTotal = {callableTarget}()
-    print(foldsTotal, time.perf_counter() - timeStart)
-    writeStream = open('{pathFilenameFoldsTotal.as_posix()}', 'w')
-    writeStream.write(str(foldsTotal))
-    writeStream.close()
+	import time
+	timeStart = time.perf_counter()
+	foldsTotal = {callableTarget}()
+	print(foldsTotal, time.perf_counter() - timeStart)
+	writeStream = open('{pathFilenameFoldsTotal.as_posix()}', 'w')
+	writeStream.write(str(foldsTotal))
+	writeStream.close()
 """
-    return ast.parse(linesLaunch)
-
-def addReturnJobNumba(FunctionDefTarget: ast.FunctionDef, stateJob: computationState, allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
-    """Add multiplication and return statement to function, properly constructing AST nodes."""
-    # Create AST for multiplication operation
-    multiplicand = Z0Z_identifierCountFolds
-    datatype = hackSSOTdatatype(multiplicand)
-    multiplyOperation = ast.BinOp(
-        left=ast.Name(id=multiplicand, ctx=ast.Load()),
-        op=ast.Mult(), right=ast.Constant(value=int(stateJob['foldGroups'][-1])))
-
-    returnStatement = ast.Return(value=multiplyOperation)
-
-    datatypeModuleScalar = Z0Z_getDatatypeModuleScalar()
-    allImports.addImportFromStr(datatypeModuleScalar, datatype)
-    FunctionDefTarget.returns = ast.Name(id=datatype, ctx=ast.Load())
-
-    FunctionDefTarget.body.append(returnStatement)
-
-    return FunctionDefTarget, allImports
-
-def unrollWhileLoop(FunctionDefTarget: ast.FunctionDef, iteratorName: str, iterationsTotal: int, connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[numpy.integer[Any]]]) -> ast.FunctionDef:
-    """
-    Unroll the countGaps loop: in theDao, it is a while loop, of course.
-    However, it could be written as `for indexDimension in range(dimensionsTotal):`.
-    It is useful to note that it could also be written as `for indexDimension in range(connectionGraph.shape[0]):`.
-    We will unroll the loop into a series of stateJob['my'][indexMy.dimensionsTotal]-many code blocks that are similar but not identical.
-    In each code block, we know the value of the identifier `indexDimension`, so we replace the identifier with its value.
-    Furthermore, we will split connectionGraph into arrays along the first axis.
-    `connectionGraph[indexDimension, leaf1ndex, leafBelow[leafConnectee]]`
-    `connectionGraph0[leaf1ndex, leafBelow[leafConnectee]]`
-    `connectionGraph1[leaf1ndex, leafBelow[leafConnectee]]`
-    `connectionGraphN[leaf1ndex, leafBelow[leafConnectee]]`
-
-    After unrolling, we can remove three `indexDimension` statements: 1) the first initialization, which is really a memory allocation, 2) the loop initialization, and 3) the loop increment.
-    """
-    return FunctionDefTarget
+	return ast.parse(linesLaunch)
+
+def makeAstModuleForOneCallable(pythonSource: str, callableTarget: str, parametersNumba: Optional[ParametersNumba]=None, inlineCallables: Optional[bool]=False , unpackArrays: Optional[bool]=False , allImports: Optional[UniversalImportTracker]=None ) -> str:
+	astModule: ast.Module = ast.parse(pythonSource, type_comments=True)
+
+	if allImports is None:
+		allImports = UniversalImportTracker()
+	for statement in astModule.body:
+		if isinstance(statement, (ast.Import, ast.ImportFrom)):
+			allImports.addAst(statement)
+
+	if inlineCallables:
+		dictionaryFunctionDef = {statement.name: statement for statement in astModule.body if isinstance(statement, ast.FunctionDef)}
+		callableInlinerWorkhorse = RecursiveInliner(dictionaryFunctionDef)
+		FunctionDefTarget = callableInlinerWorkhorse.inlineFunctionBody(callableTarget)
+	else:
+		FunctionDefTarget = next((node for node in astModule.body if isinstance(node, ast.FunctionDef) and node.name == callableTarget), None)
+	if not FunctionDefTarget:
+		raise ValueError(f"Could not find function {callableTarget} in source code")
+
+	ast.fix_missing_locations(FunctionDefTarget)
+
+	FunctionDefTarget, allImports = decorateCallableWithNumba(FunctionDefTarget, allImports, parametersNumba)
+
+	# NOTE vestigial hardcoding
+	if unpackArrays:
+		for tupleUnpack in [(indexMy, 'my'), (indexTrack, 'track')]:
+			unpacker = UnpackArrays(*tupleUnpack)
+			FunctionDefTarget = cast(ast.FunctionDef, unpacker.visit(FunctionDefTarget))
+			ast.fix_missing_locations(FunctionDefTarget)
+
+	astModule = ast.Module(body=cast(List[ast.stmt], allImports.makeListAst() + [FunctionDefTarget]), type_ignores=[])
+	ast.fix_missing_locations(astModule)
+	return ast.unparse(astModule)
+
+def decorateCallableWithNumba(FunctionDefTarget: ast.FunctionDef, allImports: UniversalImportTracker, parametersNumba: Optional[ParametersNumba]=None) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+	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.
+		for decoratorItem in astCallable.decorator_list.copy():
+			import warnings
+			astCallable.decorator_list.remove(decoratorItem)
+			warnings.warn(f"Removed decorator {ast.unparse(decoratorItem)} from {astCallable.name}")
+		return astCallable
+
+	def make_arg4parameter(signatureElement: ast.arg) -> ast.Subscript | None:
+		if isinstance(signatureElement.annotation, ast.Subscript) and isinstance(signatureElement.annotation.slice, ast.Tuple):
+			annotationShape = signatureElement.annotation.slice.elts[0]
+			if isinstance(annotationShape, ast.Subscript) and isinstance(annotationShape.slice, ast.Tuple):
+				shapeAsListSlices = [ast.Slice() for axis in range(len(annotationShape.slice.elts))]
+				shapeAsListSlices[-1] = ast.Slice(step=ast.Constant(value=1))
+				shapeAST = ast.Tuple(elts=list(shapeAsListSlices), ctx=ast.Load())
+			else:
+				shapeAST = ast.Slice(step=ast.Constant(value=1))
+
+			annotationDtype = signatureElement.annotation.slice.elts[1]
+			if (isinstance(annotationDtype, ast.Subscript) and isinstance(annotationDtype.slice, ast.Attribute)):
+				datatypeAST = annotationDtype.slice.attr
+			else:
+				datatypeAST = None
+
+			ndarrayName = signatureElement.arg
+			Z0Z_hacky_dtype = hackSSOTdatatype(ndarrayName)
+			datatype_attr = datatypeAST or Z0Z_hacky_dtype
+			allImports.addImportFromStr(datatypeModuleDecorator, datatype_attr)
+			datatypeNumba = ast.Name(id=datatype_attr, ctx=ast.Load())
+
+			return ast.Subscript(value=datatypeNumba, slice=shapeAST, ctx=ast.Load())
+		return
+
+	datatypeModuleDecorator = Z0Z_getDatatypeModuleScalar()
+	list_argsDecorator: Sequence[ast.expr] = []
+
+	list_arg4signature_or_function: List[ast.expr] = []
+	for parameter in FunctionDefTarget.args.args:
+		signatureElement = make_arg4parameter(parameter)
+		if signatureElement:
+			list_arg4signature_or_function.append(signatureElement)
+
+	if FunctionDefTarget.returns and isinstance(FunctionDefTarget.returns, ast.Name):
+		theReturn: ast.Name = FunctionDefTarget.returns
+		list_argsDecorator = [cast(ast.expr, ast.Call(func=ast.Name(id=theReturn.id, ctx=ast.Load())
+							, args=list_arg4signature_or_function if list_arg4signature_or_function else [] , keywords=[] ) )]
+	elif list_arg4signature_or_function:
+		list_argsDecorator = [cast(ast.expr, ast.Tuple(elts=list_arg4signature_or_function, ctx=ast.Load()))]
+
+	for decorator in FunctionDefTarget.decorator_list.copy():
+		if thisIsAnyNumbaJitDecorator(decorator):
+			decorator = cast(ast.Call, decorator)
+			if parametersNumba is None:
+				parametersNumbaSherpa = Then.copy_astCallKeywords(decorator)
+				if (HunterIsSureThereAreBetterWaysToDoThis := True):
+					if parametersNumbaSherpa:
+						parametersNumba = cast(ParametersNumba, parametersNumbaSherpa)
+		FunctionDefTarget.decorator_list.remove(decorator)
+
+	FunctionDefTarget = Z0Z_UnhandledDecorators(FunctionDefTarget)
+	if parametersNumba is None:
+		parametersNumba = parametersNumbaDEFAULT
+	listDecoratorKeywords = [ast.keyword(arg=parameterName, value=ast.Constant(value=parameterValue)) for parameterName, parameterValue in parametersNumba.items()]
+
+	decoratorModule = Z0Z_getDatatypeModuleScalar()
+	decoratorCallable = Z0Z_getDecoratorCallable()
+	allImports.addImportFromStr(decoratorModule, decoratorCallable)
+	astDecorator = Then.make_astCall(decoratorCallable, list_argsDecorator, listDecoratorKeywords, None)
+
+	FunctionDefTarget.decorator_list = [astDecorator]
+	return FunctionDefTarget, allImports