mapFolding 0.3.9__py3-none-any.whl → 0.3.10__py3-none-any.whl

mapFolding/someAssemblyRequired/synthesizeJobNumba.py

@@ -0,0 +1,383 @@
+"""
+It's rough, but it works. Actually, the modules it produces are lightening fast.
+
+Specific issues:
+- When trying to run the synthesized file, `ModuleNotFoundError: No module named '<dynamic>'` unless I first re-save the file in the IDE.
+- ast interprets the signature as `def countSequential() -> None:` even though there is a return statement.
+- Similarly, but possibly my fault, `decorateCallableWithNumba` doesn't add the return type to the signature.
+
+General issues:
+- an ironic dearth of abstract functionality in this module based on ast.
+    - I don't have much experience with ast.
+    - ast is one of the few cases that absolutely benefits from an OOP paradigm, and I am comically inept at OOP.
+- (almost) Everything prefixed with `Z0Z_` is something I want to substantially improve.
+- convergence with other synthesize modules and functions would be good.
+- while management of datatypes seems to be pretty good, managing pathFilenames could be better.
+- as of this writing, there are zero direct tests for `someAssemblyRequired`.
+"""
+from mapFolding import indexMy, indexTrack, ParametersNumba, parametersNumbaDEFAULT, getFilenameFoldsTotal, getPathJobRootDEFAULT, getPathFilenameFoldsTotal
+from mapFolding import setDatatypeElephino, setDatatypeFoldsTotal, setDatatypeLeavesTotal, setDatatypeModule, hackSSOTdatatype, computationState
+from mapFolding.someAssemblyRequired import makeStateJob, decorateCallableWithNumba, Z0Z_UnhandledDecorators
+from typing import Optional, Callable, List, Sequence, cast, Dict, Set, Any, Union
+from Z0Z_tools import updateExtendPolishDictionaryLists
+import ast
+import collections
+import importlib
+import importlib.util
+import inspect
+import more_itertools
+import numpy
+import os
+import pathlib
+import python_minifier
+
+dictionaryImportFrom: Dict[str, List[str]] = collections.defaultdict(list)
+datatypeModuleScalar = 'numba'
+
+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})"
+
+    Example:
+        >>> arr = numpy.array([[0,0,0,1,2,3,4,0,0]])
+        >>> print(makeStrRLEcompacted(arr, "myArray"))
+        "myArray = numpy.array([[0]*3,*range(1,5),[0]*2], dtype=numpy.int64)"
+    """
+
+    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 makeImports() -> List[List[ast.ImportFrom]]:
+    global dictionaryImportFrom
+    dictionaryImportFrom = updateExtendPolishDictionaryLists(dictionaryImportFrom, destroyDuplicates=True)
+
+    def parseAlias(aliasString: str):
+        parts = aliasString.split(" as ")
+        if len(parts) == 2:
+            return ast.alias(name=parts[0].strip(), asname=parts[1].strip())
+        return ast.alias(name=aliasString.strip(), asname=None)
+
+    importStatements = [[
+        ast.ImportFrom(module=module, names=[ast.alias(name=identifierName, asname=None)
+                                            for identifierName in listIdentifiers], level=0)
+                                            for module, listIdentifiers in dictionaryImportFrom.items()]
+        ]
+
+    return importStatements
+
+def evaluateArrayIn_body(node: ast.FunctionDef, astArg: ast.arg, argData: numpy.ndarray) -> ast.FunctionDef:
+    global dictionaryImportFrom
+    arrayType = type(argData)
+    moduleConstructor = arrayType.__module__
+    constructorName = arrayType.__name__
+    # NOTE hack
+    constructorName = constructorName.replace('ndarray', 'array')
+    dictionaryImportFrom[moduleConstructor].append(constructorName)
+
+    for stmt in node.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)
+                dictionaryImportFrom[moduleConstructor].append(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 )
+                    node.body.insert(0, assignment)
+                    node.body.remove(stmt)
+
+    node.args.args.remove(astArg)
+    return node
+
+def evaluate_argIn_body(node: ast.FunctionDef, astArg: ast.arg, argData: numpy.ndarray, Z0Z_listChaff: List[str]) -> ast.FunctionDef:
+    global dictionaryImportFrom
+    moduleConstructor = datatypeModuleScalar
+    for stmt in node.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)
+                dictionaryImportFrom[moduleConstructor].append(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:
+                        node.body.insert(0, assignment)
+                    node.body.remove(stmt)
+    node.args.args.remove(astArg)
+    return node
+
+def evaluateAnnAssignIn_body(node: ast.FunctionDef) -> ast.FunctionDef:
+    global dictionaryImportFrom
+    moduleConstructor = datatypeModuleScalar
+    for stmt in node.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)
+                dictionaryImportFrom[moduleConstructor].append(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)
+                node.body.insert(0, assignment)
+                node.body.remove(stmt)
+    return node
+
+def move_argTo_body(node: ast.FunctionDef, astArg: ast.arg, argData: numpy.ndarray) -> ast.FunctionDef:
+    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
+
+    global dictionaryImportFrom
+    dictionaryImportFrom[moduleConstructor].append(constructorName)
+    dictionaryImportFrom[moduleConstructor].append(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 )
+    node.body.insert(0, assignment)
+    node.args.args.remove(astArg)
+
+    return node
+
+def makeDecorator(FunctionDefTarget: ast.FunctionDef, parametersNumba: Optional[ParametersNumba]=None) -> ast.FunctionDef:
+    if parametersNumba is None:
+        parametersNumbaExtracted: Dict[str, Any] = {}
+        for decoratorItem in FunctionDefTarget.decorator_list.copy():
+            if isinstance(decoratorItem, ast.Call) and isinstance(decoratorItem.func, ast.Attribute):
+                if getattr(decoratorItem.func.value, "id", None) == "numba" and decoratorItem.func.attr == "jit":
+                    FunctionDefTarget.decorator_list.remove(decoratorItem)
+                    for keywordItem in decoratorItem.keywords:
+                        if isinstance(keywordItem.value, ast.Constant) and keywordItem.arg is not None:
+                            parametersNumbaExtracted[keywordItem.arg] = keywordItem.value.value
+        if parametersNumbaExtracted:
+            parametersNumba = ParametersNumba(parametersNumbaExtracted)  # type: ignore
+    else:
+        # TODO code duplication
+        for decoratorItem in FunctionDefTarget.decorator_list.copy():
+            if isinstance(decoratorItem, ast.Call) and isinstance(decoratorItem.func, ast.Attribute):
+                if getattr(decoratorItem.func.value, "id", None) == "numba" and decoratorItem.func.attr == "jit":
+                    FunctionDefTarget.decorator_list.remove(decoratorItem)
+    FunctionDefTarget = Z0Z_UnhandledDecorators(FunctionDefTarget)
+    global dictionaryImportFrom
+    dictionaryImportFrom['numba'].append('jit')
+    FunctionDefTarget = decorateCallableWithNumba(FunctionDefTarget, parametersNumba)
+    # make sure the decorator is rendered as `@jit` and not `@numba.jit`
+    for decoratorItem in FunctionDefTarget.decorator_list:
+        if isinstance(decoratorItem, ast.Call) and isinstance(decoratorItem.func, ast.Attribute) and decoratorItem.func.attr == "jit":
+            decoratorItem.func = ast.Name(id="jit", ctx=ast.Load())
+    return FunctionDefTarget
+
+def makeLauncher(identifierCallable: str) -> ast.Module:
+    linesLaunch = f"""
+if __name__ == '__main__':
+    import time
+    timeStart = time.perf_counter()
+    {identifierCallable}()
+    print(time.perf_counter() - timeStart)
+"""
+    astLaunch = ast.parse(linesLaunch)
+    return astLaunch
+
+def make_writeFoldsTotal(stateJob: computationState, pathFilenameFoldsTotal: pathlib.Path) -> ast.Module:
+    global dictionaryImportFrom
+    dictionaryImportFrom['numba'].append("objmode")
+    linesWriteFoldsTotal = f"""
+groupsOfFolds *= {str(stateJob['foldGroups'][-1])}
+print(groupsOfFolds)
+with objmode():
+    open('{pathFilenameFoldsTotal.as_posix()}', 'w').write(str(groupsOfFolds))
+return groupsOfFolds
+    """
+    return ast.parse(linesWriteFoldsTotal)
+
+def removeIdentifierFrom_body(node: ast.FunctionDef, astArg: ast.arg) -> ast.FunctionDef:
+    for stmt in node.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:
+                    node.body.remove(stmt)
+    node.args.args.remove(astArg)
+    return node
+
+def astObjectToAstConstant(astFunction: 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)
+
+    class ReplaceObjectWithConstant(ast.NodeTransformer):
+        def __init__(self, targetDump: str, constantValue: int) -> None:
+            self.targetDump = targetDump
+            self.constantValue = constantValue
+
+        def generic_visit(self, node: ast.AST) -> ast.AST:
+            currentDump = ast.dump(node, annotate_fields=False)
+            if currentDump == self.targetDump:
+                return ast.copy_location(ast.Constant(value=self.constantValue), node)
+            return super().generic_visit(node)
+
+    transformer = ReplaceObjectWithConstant(targetDump, value)
+    newFunction = transformer.visit(astFunction)
+    ast.fix_missing_locations(newFunction)
+    return newFunction
+
+def astNameToAstConstant(astFunction: ast.FunctionDef, name: str, value: int) -> ast.FunctionDef:
+    class ReplaceNameWithConstant(ast.NodeTransformer):
+        def visit_Name(self, node: ast.Name) -> ast.AST:
+            if node.id == name:
+                return ast.copy_location(ast.Constant(value=value), node)
+            return node
+    return ReplaceNameWithConstant().visit(astFunction)
+
+def writeJobNumba(listDimensions: Sequence[int], callableSource: Callable, parametersNumba: Optional[ParametersNumba]=None, pathFilenameWriteJob: Optional[Union[str, os.PathLike[str]]] = None) -> pathlib.Path:
+    stateJob = makeStateJob(listDimensions, writeJob=False)
+    codeSource = inspect.getsource(callableSource)
+    astSource = ast.parse(codeSource)
+
+    pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateJob['mapShape'])
+
+    FunctionDefTarget = next((node for node in astSource.body if isinstance(node, ast.FunctionDef) and node.name == callableSource.__name__), None)
+
+    if not FunctionDefTarget:
+        raise ValueError(f"Could not find function {callableSource.__name__} in source code")
+
+    Z0Z_listArgsTarget = ['connectionGraph', 'gapsWhere']
+    Z0Z_listArraysEvaluate = ['track']
+    Z0Z_listArgsEvaluate = ['my']
+    Z0Z_listChaff = ['taskIndex', 'dimensionsTotal']
+    Z0Z_listArgsRemove = ['foldGroups']
+    for astArgument in FunctionDefTarget.args.args.copy():
+        if astArgument.arg in Z0Z_listArgsTarget:
+            FunctionDefTarget = move_argTo_body(FunctionDefTarget, astArgument, stateJob[astArgument.arg])
+        elif astArgument.arg in Z0Z_listArraysEvaluate:
+            FunctionDefTarget = evaluateArrayIn_body(FunctionDefTarget, astArgument, stateJob[astArgument.arg])
+        elif astArgument.arg in Z0Z_listArgsEvaluate:
+            FunctionDefTarget = evaluate_argIn_body(FunctionDefTarget, astArgument, stateJob[astArgument.arg], Z0Z_listChaff)
+        elif astArgument.arg in Z0Z_listArgsRemove:
+            FunctionDefTarget = removeIdentifierFrom_body(FunctionDefTarget, astArgument)
+
+    FunctionDefTarget = evaluateAnnAssignIn_body(FunctionDefTarget)
+    FunctionDefTarget = astNameToAstConstant(FunctionDefTarget, 'dimensionsTotal', int(stateJob['my'][indexMy.dimensionsTotal]))
+    FunctionDefTarget = astObjectToAstConstant(FunctionDefTarget, 'foldGroups[-1]', int(stateJob['foldGroups'][-1]))
+
+    global identifierCallableLaunch
+    identifierCallableLaunch = FunctionDefTarget.name
+
+    FunctionDefTarget = makeDecorator(FunctionDefTarget, parametersNumba)
+
+    astWriteFoldsTotal = make_writeFoldsTotal(stateJob, pathFilenameFoldsTotal)
+    FunctionDefTarget.body += astWriteFoldsTotal.body
+
+    astLauncher = makeLauncher(FunctionDefTarget.name)
+
+    astImports = makeImports()
+
+    astModule = ast.Module(
+        body=cast(List[ast.stmt]
+                , astImports
+                + [FunctionDefTarget]
+                + [astLauncher])
+        , type_ignores=[]
+    )
+    ast.fix_missing_locations(astModule)
+
+    codeSource = ast.unparse(astModule)
+
+    if pathFilenameWriteJob is None:
+        filename = getFilenameFoldsTotal(stateJob['mapShape'])
+        pathRoot = getPathJobRootDEFAULT()
+        pathFilenameWriteJob = pathlib.Path(pathRoot, pathlib.Path(filename).stem, pathlib.Path(filename).with_suffix('.py'))
+    else:
+        pathFilenameWriteJob = pathlib.Path(pathFilenameWriteJob)
+    pathFilenameWriteJob.parent.mkdir(parents=True, exist_ok=True)
+
+    pathFilenameWriteJob.write_text(codeSource)
+    return pathFilenameWriteJob
+
+if __name__ == '__main__':
+    listDimensions = [2,15]
+    setDatatypeFoldsTotal('int64', sourGrapes=True)
+    setDatatypeElephino('uint8', sourGrapes=True)
+    setDatatypeLeavesTotal('uint8', sourGrapes=True)
+    from mapFolding.syntheticModules.numba_countSequential import countSequential
+    callableSource = countSequential
+    pathFilenameModule = writeJobNumba(listDimensions, callableSource, parametersNumbaDEFAULT)
+
+    # Induce numba.jit compilation
+    # TODO Inducing compilation might be causing the `ModuleNotFoundError: No module named '<dynamic>'` error
+
+    # moduleSpec = importlib.util.spec_from_file_location(pathFilenameModule.stem, pathFilenameModule)
+    # if moduleSpec is None: raise ImportError(f"Could not load module specification from {pathFilenameModule}")
+    # module = importlib.util.module_from_spec(moduleSpec)
+    # if moduleSpec.loader is None: raise ImportError(f"Could not load module from {moduleSpec}")
+    # moduleSpec.loader.exec_module(module)
+
+    # from mapFolding.someAssemblyRequired.getLLVMforNoReason import writeModuleLLVM
+    # pathFilenameLLVM = writeModuleLLVM(pathFilenameModule, identifierCallableLaunch)

mapFolding/someAssemblyRequired/synthesizeModuleJAX.py

@@ -1,4 +1,4 @@
-from mapFolding import getAlgorithmSource, relativePathSyntheticModules
+from mapFolding import getAlgorithmSource, getPathSyntheticModules
 from mapFolding import setDatatypeModule, setDatatypeFoldsTotal, setDatatypeElephino, setDatatypeLeavesTotal
 from typing import Optional
 import ast
@@ -18,7 +18,7 @@ def writeJax(*, codeSource: Optional[str] = None, pathFilenameAlgorithm: Optiona
     else:
         raise NotImplementedError("You haven't written this part yet.")
     if pathFilenameDestination is None:
-        pathFilenameDestination = pathFilenameAlgorithm.parent / relativePathSyntheticModules / "countJax.py"
+        pathFilenameDestination = getPathSyntheticModules() / "countJax.py"
     # pathFilenameDestination.write_text(transformedText)
 
 if __name__ == '__main__':

mapFolding/someAssemblyRequired/synthesizeModulesNumba.py

@@ -10,6 +10,9 @@ from mapFolding import (
     moduleOfSyntheticModules,
     myPackageNameIs,
     ParametersNumba,
+    parametersNumbaSuperJit,
+    parametersNumbaFailEarly,
+    parametersNumbaSuperJitParallel,
     parametersNumbaDEFAULT,
     setDatatypeElephino,
     setDatatypeFoldsTotal,
@@ -32,6 +35,14 @@ Convert types
     e.g. `groupsOfFolds: int = 0` to `groupsOfFolds = numba.types.{datatypeLarge}(0)`
     This isn't necessary for Numba, but I may the infrastructure for other compilers or paradigms."""
 
+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
+
 class RecursiveInliner(ast.NodeTransformer):
     """
     Class RecursiveInliner:
@@ -93,7 +104,7 @@ class RecursiveInliner(ast.NodeTransformer):
                     return [self.visit(stmt) for stmt in inlineDefinition.body]
         return self.generic_visit(node)
 
-def decorateCallableWithNumba(astCallable: ast.FunctionDef, parallel: bool=False) -> ast.FunctionDef:
+def decorateCallableWithNumba(astCallable: ast.FunctionDef, parametersNumba: Optional[ParametersNumba]=None) -> ast.FunctionDef:
     """
     Decorates an AST function definition with Numba JIT compilation parameters.
 
@@ -181,8 +192,7 @@ def decorateCallableWithNumba(astCallable: ast.FunctionDef, parallel: bool=False
 
             return ast.Subscript(value=datatypeNumba, slice=shapeAST, ctx=ast.Load())
 
-    # TODO: more explicit handling of decorators. I'm able to ignore this because I know `algorithmSource` doesn't have any decorators.
-    # callableSourceDecorators = [decorator for decorator in callableInlined.decorator_list]
+    astCallable = Z0Z_UnhandledDecorators(astCallable)
 
     listNumbaParameterSignature: Sequence[ast.expr] = []
     for parameter in astCallable.args.args:
@@ -190,15 +200,31 @@ def decorateCallableWithNumba(astCallable: ast.FunctionDef, parallel: bool=False
         if (signatureElement):
             listNumbaParameterSignature.append(signatureElement)
 
-    astArgsNumbaSignature = ast.Tuple(elts=listNumbaParameterSignature, ctx=ast.Load())
-
-    if astCallable.name == 'countInitialize' or astCallable.name == 'doTheNeedful':
-        parametersNumba = {}
+    astTupleSignatureParameters = ast.Tuple(elts=listNumbaParameterSignature, ctx=ast.Load())
+
+    # TODO if `astCallable` has a return, the return needs to be added to `astArgsNumbaSignature` in the appropriate place
+    # The return, when placed in the args, is treated as a `Call`. This is logical because numba is converting to machine code.
+    # , args=[Call(func=Name(id='int64', ctx=Load()))]
+    ast_argsSignature = astTupleSignatureParameters
+
+    ImaReturn = next((node for node in astCallable.body if isinstance(node, ast.Return)), None)
+    # Return(value=Name(id='groupsOfFolds', ctx=Load()))]
+    if ImaReturn is not None and isinstance(ImaReturn.value, ast.Name):
+        my_idIf_I_wereA_astCall_func_astName_idParameter = ImaReturn.value.id
+        ast_argsSignature = ast.Call(
+                func=ast.Name(id=my_idIf_I_wereA_astCall_func_astName_idParameter, ctx=ast.Load()),
+                args=[astTupleSignatureParameters],
+                keywords=[]
+            )
     else:
-        parametersNumba = parametersNumbaDEFAULT if not parallel else ParametersNumba({**parametersNumbaDEFAULT, 'parallel': True})
+        ast_argsSignature = astTupleSignatureParameters
+
+    if parametersNumba is None:
+        parametersNumba = parametersNumbaDEFAULT
+
     listKeywordsNumbaSignature = [ast.keyword(arg=parameterName, value=ast.Constant(value=parameterValue)) for parameterName, parameterValue in parametersNumba.items()]
 
-    astDecoratorNumba = ast.Call(func=ast.Attribute(value=ast.Name(id='numba', ctx=ast.Load()), attr='jit', ctx=ast.Load()), args=[astArgsNumbaSignature], keywords=listKeywordsNumbaSignature)
+    astDecoratorNumba = ast.Call(func=ast.Attribute(value=ast.Name(id='numba', ctx=ast.Load()), attr='jit', ctx=ast.Load()), args=[ast_argsSignature], keywords=listKeywordsNumbaSignature)
 
     astCallable.decorator_list = [astDecoratorNumba]
     return astCallable
@@ -311,6 +337,7 @@ class UnpackArrayAccesses(ast.NodeTransformer):
         return node
 
 def inlineOneCallable(codeSource: str, callableTarget: str):
+
     """
     Inlines a target callable function and its dependencies within the provided code source.
 
@@ -347,8 +374,17 @@ def inlineOneCallable(codeSource: str, callableTarget: str):
 
     if callableInlined:
         ast.fix_missing_locations(callableInlined)
-        parallel = callableTarget == 'countParallel'
-        callableDecorated = decorateCallableWithNumba(callableInlined, parallel)
+        parametersNumba = None
+
+        match callableTarget:
+            case 'countParallel':
+                parametersNumba = parametersNumbaSuperJitParallel
+            case 'countSequential':
+                parametersNumba = parametersNumbaSuperJit
+            case 'countInitialize':
+                parametersNumba = parametersNumbaDEFAULT
+
+        callableDecorated = decorateCallableWithNumba(callableInlined, parametersNumba)
 
         if callableTarget == 'countSequential':
             unpackerMy = UnpackArrayAccesses(indexMy, 'my')
@@ -365,59 +401,50 @@ def inlineOneCallable(codeSource: str, callableTarget: str):
         return moduleSource
 
 def makeDispatcherNumba(codeSource: str, callableTarget: str, listStuffYouOughtaKnow: List[youOughtaKnow]) -> str:
-    """Creates AST for the dispatcher module that coordinates the optimized functions."""
-    docstringDispatcherNumba = """
-        What in tarnation is this stupid module and function?
-
-        - This function is not in the same module as `countFolds` so that we can delay Numba just-in-time (jit) compilation of this function and the finalization of its settings until we are ready.
-        - This function is not in the same module as the next function, which does the hard work, so that we can delay `numba.jit` compilation of the next function.
-        - This function is "jitted" but the next function is super jitted, which makes it too arrogant to talk to plebian Python functions. It will, however, reluctantly talk to basic jitted functions.
-        - So this module can talk to the next function, and because this module isn't as arrogant, it will talk to the low-class `countFolds` that called this function. Well, with a few restrictions, of course:
-            - No `TypedDict`
-            - The plebs must clean up their own memory problems
-            - No oversized integers
-            - No global variables, only global constants
-            - It won't accept pleb nonlocal variables either
-            - Python "class": they are all inferior to the jit class
-            - No `**kwargs`
-            - and just a few dozen-jillion other things.
-        """
 
-    # Parse source code
-    sourceAST = ast.parse(codeSource)
+    docstringDispatcherNumba = """What in tarnation is this stupid module and function?
+
+    - This function is not in the same module as `countFolds` so that we can delay Numba just-in-time (jit) compilation of this function and the finalization of its settings until we are ready.
+    - This function is not in the same module as the next function, which does the hard work, so that we can delay `numba.jit` compilation of the next function.
+    - This function is "jitted" but the next function is super jitted, which makes it too arrogant to talk to plebian Python functions. It will, however, reluctantly talk to basic jitted functions.
+    - So this module can talk to the next function, and because this module isn't as arrogant, it will talk to the low-class `countFolds` that called this function. Well, with a few restrictions, of course:
+        - No `TypedDict`
+        - The plebs must clean up their own memory problems
+        - No oversized integers
+        - No global variables, only global constants
+        - It won't accept pleb nonlocal variables either
+        - Python "class": they are all inferior to the jit class
+        - No `**kwargs`
+        - and just a few dozen-jillion other things."""
 
-    # Extract imports and target function definition
-    importsAST = [node for node in sourceAST.body if isinstance(node, (ast.Import, ast.ImportFrom))]
-    FunctionDefTarget = next((node for node in sourceAST.body if isinstance(node, ast.FunctionDef) and node.name == callableTarget), None)
+    astSource = ast.parse(codeSource)
+
+    astImports = [node for node in astSource.body if isinstance(node, (ast.Import, ast.ImportFrom))]
+    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")
 
     # Zero-out the decorator list
-    FunctionDefTarget.decorator_list=[]
-    # TODO: more explicit handling of decorators. I'm able to ignore this because I know `algorithmSource` doesn't have any decorators.
-    # FunctionDefTargetDecorators = [decorator for decorator in FunctionDefTarget.decorator_list]
+    FunctionDefTarget = Z0Z_UnhandledDecorators(FunctionDefTarget)
 
     # Add Numba decorator
-    FunctionDefTarget = decorateCallableWithNumba(FunctionDefTarget, parallel=False)
+    FunctionDefTarget = decorateCallableWithNumba(FunctionDefTarget, parametersNumbaFailEarly)
     FunctionDefTarget.body.insert(0, ast.Expr(value=ast.Constant(value=docstringDispatcherNumba)))
 
-    # Combine everything into a module
-    moduleAST = ast.Module(
+    astModule = ast.Module(
         body=cast(List[ast.stmt]
-                , importsAST
+                , astImports
                 + [Don_Lapre_The_Road_to_Self_Improvement_For_Programmers_by_Using_Short_Identifiers.astForCompetentProgrammers
                     for Don_Lapre_The_Road_to_Self_Improvement_For_Programmers_by_Using_Short_Identifiers in listStuffYouOughtaKnow]
                 + [FunctionDefTarget])
         , type_ignores=[]
     )
 
-    ast.fix_missing_locations(moduleAST)
-    return ast.unparse(moduleAST)
+    ast.fix_missing_locations(astModule)
+    return ast.unparse(astModule)
 
 def makeNumbaOptimizedFlow(listCallablesInline: List[str], callableDispatcher: Optional[str] = None, algorithmSource: Optional[ModuleType] = None):
-    """Synthesizes numba-optimized versions of map folding functions."""
-
     if not algorithmSource:
         algorithmSource = getAlgorithmSource()
 

mapFolding/syntheticModules/numba_countInitialize.py

@@ -1,12 +1,11 @@
-from numpy.typing import NDArray
+from typing import Any, Tuple
 import numpy
-from numpy import integer
+from numpy import dtype, integer, ndarray
 import numba
 from mapFolding import indexMy, indexTrack
-from typing import Any, Tuple
 
-@numba.jit((numba.uint8[:, :, ::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]))
-def countInitialize(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> None:
+@numba.jit((numba.uint8[:, :, ::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
+def countInitialize(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
     while my[indexMy.leaf1ndex.value]:
         if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
             my[indexMy.dimensionsUnconstrained.value] = my[indexMy.dimensionsTotal.value]

mapFolding/syntheticModules/numba_countParallel.py

@@ -1,12 +1,11 @@
-from numpy.typing import NDArray
-import numpy
-from numpy import integer
-import numba
 from mapFolding import indexMy, indexTrack
 from typing import Any, Tuple
+import numpy
+from numpy import dtype, integer, ndarray
+import numba
 
-@numba.jit((numba.uint8[:, :, ::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=False, inline='never', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=True)
-def countParallel(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], foldGroups: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> None:
+@numba.jit((numba.uint8[:, :, ::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=True)
+def countParallel(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
     gapsWherePARALLEL = gapsWhere.copy()
     myPARALLEL = my.copy()
     trackPARALLEL = track.copy()

mapFolding/syntheticModules/numba_countSequential.py

@@ -1,12 +1,11 @@
-from numpy.typing import NDArray
 import numpy
-from numpy import integer
+from numpy import dtype, integer, ndarray
 import numba
 from mapFolding import indexMy, indexTrack
 from typing import Any, Tuple
 
-@numba.jit((numba.uint8[:, :, ::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=False, inline='never', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=False)
-def countSequential(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], foldGroups: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> None:
+@numba.jit((numba.uint8[:, :, ::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=False)
+def countSequential(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
     leafBelow = track[indexTrack.leafBelow.value]
     gapRangeStart = track[indexTrack.gapRangeStart.value]
     countDimensionsGapped = track[indexTrack.countDimensionsGapped.value]