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

{someAssemblyRequired → mapFolding/someAssemblyRequired}/synthesizeModulesNumba.py

@@ -1,18 +1,48 @@
-from mapFolding import EnumIndices, relativePathSyntheticModules, setDatatypeElephino, setDatatypeFoldsTotal, setDatatypeLeavesTotal, setDatatypeModule
-from mapFolding import indexMy, indexTrack, getAlgorithmSource, ParametersNumba, parametersNumbaDEFAULT, hackSSOTdatatype, hackSSOTdtype
-from typing import cast, Dict, List, Optional, Sequence, Set, Type, Union
+from mapFolding import (
+    EnumIndices,
+    getAlgorithmSource,
+    getPathPackage,
+    getPathSyntheticModules,
+    hackSSOTdatatype,
+    hackSSOTdtype,
+    indexMy,
+    indexTrack,
+    moduleOfSyntheticModules,
+    myPackageNameIs,
+    ParametersNumba,
+    parametersNumbaSuperJit,
+    parametersNumbaFailEarly,
+    parametersNumbaSuperJitParallel,
+    parametersNumbaDEFAULT,
+    setDatatypeElephino,
+    setDatatypeFoldsTotal,
+    setDatatypeLeavesTotal,
+    setDatatypeModule,
+)
+from typing import cast, Dict, List, Optional, Sequence, Set, Tuple, Type, Union
 from types import ModuleType
+from collections import namedtuple
 import ast
 import inspect
 import numba
 import numpy
 import pathlib
 
+youOughtaKnow = namedtuple('youOughtaKnow', ['callableSynthesized', 'pathFilenameForMe', 'astForCompetentProgrammers'])
+
 """TODO
 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:
@@ -53,8 +83,8 @@ class RecursiveInliner(ast.NodeTransformer):
             self.visit(astNode)
         return inlineDefinition
 
-    def visit_Call(self, callNode: ast.Call) -> ast.AST:
-        callNodeVisited = self.generic_visit(callNode)
+    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):
@@ -74,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.
 
@@ -83,6 +113,7 @@ def decorateCallableWithNumba(astCallable: ast.FunctionDef, parallel: bool=False
 
     Parameters
     ----------
+
     astCallable : ast.FunctionDef
         The AST node representing the function to be decorated with Numba JIT.
     parallel : bool, optional
@@ -91,6 +122,7 @@ def decorateCallableWithNumba(astCallable: ast.FunctionDef, parallel: bool=False
 
     Returns
     -------
+
     ast.FunctionDef
         The modified AST function definition node with added Numba decorators.
 
@@ -160,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:
@@ -169,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':
-        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
@@ -289,7 +336,8 @@ class UnpackArrayAccesses(ast.NodeTransformer):
         node.body = initializations + node.body
         return node
 
-def inlineOneCallable(codeSource, callableTarget):
+def inlineOneCallable(codeSource: str, callableTarget: str):
+
     """
     Inlines a target callable function and its dependencies within the provided code source.
 
@@ -326,8 +374,17 @@ def inlineOneCallable(codeSource, callableTarget):
 
     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')
@@ -343,104 +400,134 @@ def inlineOneCallable(codeSource, callableTarget):
         moduleSource = ast.unparse(moduleAST)
         return moduleSource
 
-class AppendDunderInit(ast.NodeTransformer):
-    """AST transformer that validates and appends imports to __init__.py files."""
-
-    def __init__(self, listPathFilenamesDestination: list[tuple[pathlib.Path, str]]):
-        self.listPathFilenamesDestination = listPathFilenamesDestination
-        self.listTuplesDunderInit = []
-
-    def process_init_files(self) -> list[tuple[pathlib.Path, str]]:
-        for pathFilename, callableTarget in self.listPathFilenamesDestination:
-            pathDunderInit = pathFilename.parent / "__init__.py"
-
-            # Create empty init if doesn't exist
-            if not pathDunderInit.exists():
-                pathDunderInit.write_text("")
-
-            # Parse existing init file
-            try:
-                treeInit = ast.parse(pathDunderInit.read_text())
-            except SyntaxError:
-                treeInit = ast.Module(body=[], type_ignores=[])
-
-            # Compute the lowercase module target
-            moduleTarget = "." + pathFilename.stem
-            moduleTargetLower = moduleTarget.lower()
-
-            # Track existing imports as (normalizedModule, name)
-            setImportsExisting = set()
-            for node in treeInit.body:
-                if isinstance(node, ast.ImportFrom) and node.module:
-                    # Compare on a lowercase basis
-                    if node.module.lower() == moduleTargetLower:
-                        for alias in node.names:
-                            setImportsExisting.add((moduleTargetLower, alias.name))
-
-            # Only append if this exact import doesn't exist
-            if (moduleTargetLower, callableTarget) not in setImportsExisting:
-                newImport = ast.ImportFrom(
-                    module=moduleTarget,
-                    names=[ast.alias(name=callableTarget, asname=None)],
-                    level=0
-                )
-                treeInit.body.append(newImport)
-                ast.fix_missing_locations(treeInit)
-                pathDunderInit.write_text(ast.unparse(treeInit))
-
-            self.listTuplesDunderInit.append((pathDunderInit, callableTarget))
-
-        return self.listTuplesDunderInit
-
-def inlineMapFoldingNumba(listCallablesAsStr: List[str], algorithmSource: Optional[ModuleType] = None):
-    """Synthesizes numba-optimized versions of map folding functions.
-    This function creates specialized versions of map folding functions by inlining
-    target callables and generating optimized modules. It handles the code generation
-    and file writing process.
+def makeDispatcherNumba(codeSource: str, callableTarget: str, listStuffYouOughtaKnow: List[youOughtaKnow]) -> str:
 
-    Parameters:
-        listCallablesAsStr (List[str]): List of callable names to be processed as strings.
-        algorithmSource (Optional[ModuleType], optional): Source module containing the algorithms.
-            If None, will be obtained via getAlgorithmSource(). Defaults to None.
+    docstringDispatcherNumba = """What in tarnation is this stupid module and function?
 
-    Returns:
-        List[Tuple[pathlib.Path, str]]: List of tuples containing:
-            - Generated file paths
-            - Associated callable names
+    - 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."""
 
-    Raises:
-        Exception: If inline operation fails during code generation.
+    astSource = ast.parse(codeSource)
 
-    Note:
-        - Generated files are placed in a synthetic modules subdirectory
-        - Modifies __init__.py files to expose generated modules
-        - Current implementation contains hardcoded paths that should be abstracted
-    """
+    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 = Z0Z_UnhandledDecorators(FunctionDefTarget)
+
+    # Add Numba decorator
+    FunctionDefTarget = decorateCallableWithNumba(FunctionDefTarget, parametersNumbaFailEarly)
+    FunctionDefTarget.body.insert(0, ast.Expr(value=ast.Constant(value=docstringDispatcherNumba)))
+
+    astModule = ast.Module(
+        body=cast(List[ast.stmt]
+                , 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(astModule)
+    return ast.unparse(astModule)
+
+def makeNumbaOptimizedFlow(listCallablesInline: List[str], callableDispatcher: Optional[str] = None, algorithmSource: Optional[ModuleType] = None):
     if not algorithmSource:
         algorithmSource = getAlgorithmSource()
 
-    listPathFilenamesDestination: list[tuple[pathlib.Path, str]] = []
+    formatModuleNameDEFAULT = "numba_{callableTarget}"
+
+    # When I am a more competent programmer, I will make getPathFilenameWrite dependent on makeAstImport or vice versa,
+    # so the name of the physical file doesn't get out of whack with the name of the logical module.
+    def getPathFilenameWrite(callableTarget: str
+                            , pathWrite: Optional[pathlib.Path] = None
+                            , formatFilenameWrite: Optional[str] = None
+                            ) -> pathlib.Path:
+        if not pathWrite:
+            pathWrite = getPathSyntheticModules()
+        if not formatFilenameWrite:
+            formatFilenameWrite = formatModuleNameDEFAULT + '.py'
+
+        pathFilename = pathWrite  / formatFilenameWrite.format(callableTarget=callableTarget)
+        return pathFilename
+
+    def makeAstImport(callableTarget: str
+                        , packageName: Optional[str] = None
+                        , subPackageName: Optional[str] = None
+                        , moduleName: Optional[str] = None
+                        , astNodeLogicalPathThingy: Optional[ast.AST] = None
+                        ) -> ast.ImportFrom:
+        """Creates import AST node for synthetic modules."""
+        if astNodeLogicalPathThingy is None:
+            if packageName is None:
+                packageName = myPackageNameIs
+            if subPackageName is None:
+                subPackageName = moduleOfSyntheticModules
+            if moduleName is None:
+                moduleName = formatModuleNameDEFAULT.format(callableTarget=callableTarget)
+            module=f'{packageName}.{subPackageName}.{moduleName}'
+        else:
+            module = str(astNodeLogicalPathThingy)
+        return ast.ImportFrom(
+            module=module,
+            names=[ast.alias(name=callableTarget, asname=None)],
+            level=0
+        )
+
+    listStuffYouOughtaKnow: List[youOughtaKnow] = []
+
+    for callableTarget in listCallablesInline:
+        codeSource = inspect.getsource(algorithmSource)
+        moduleSource = inlineOneCallable(codeSource, callableTarget)
+        if not moduleSource:
+            raise Exception("Pylance, OMG! The sky is falling!")
 
-    # TODO abstract this process
-    # especially remove the hardcoded paths and filenames
+        pathFilename = getPathFilenameWrite(callableTarget)
+        astImport = makeAstImport(callableTarget)
 
-    for callableTarget in listCallablesAsStr:
+        listStuffYouOughtaKnow.append(youOughtaKnow(
+            callableSynthesized=callableTarget,
+            pathFilenameForMe=pathFilename,
+            astForCompetentProgrammers=astImport
+        ))
+        pathFilename.write_text(moduleSource)
+
+    # Generate dispatcher if requested
+    if callableDispatcher:
         codeSource = inspect.getsource(algorithmSource)
-        moduleSource = inlineOneCallable(codeSource, callableTarget)
+        moduleSource = makeDispatcherNumba(codeSource, callableDispatcher, listStuffYouOughtaKnow)
         if not moduleSource:
             raise Exception("Pylance, OMG! The sky is falling!")
-        pathFilenameAlgorithm = pathlib.Path(inspect.getfile(algorithmSource))
-        pathFilenameDestination = pathFilenameAlgorithm.parent / relativePathSyntheticModules / pathFilenameAlgorithm.with_stem("numba"+callableTarget[5:None]).name
-        pathFilenameDestination.write_text(moduleSource)
-        listPathFilenamesDestination.append((pathFilenameDestination, callableTarget))
 
-    # This almost works: it duplicates existing imports, though
-    listTuplesDunderInit = AppendDunderInit(listPathFilenamesDestination).process_init_files()
+        pathFilename = getPathFilenameWrite(callableDispatcher)
+        astImport = makeAstImport(callableDispatcher)
+
+        listStuffYouOughtaKnow.append(youOughtaKnow(
+            callableSynthesized=callableDispatcher,
+            pathFilenameForMe=pathFilename,
+            astForCompetentProgrammers=astImport
+        ))
+        pathFilename.write_text(moduleSource)
 
 if __name__ == '__main__':
-    listCallablesAsStr: List[str] = ['countInitialize', 'countParallel', 'countSequential']
     setDatatypeModule('numpy', sourGrapes=True)
     setDatatypeFoldsTotal('int64', sourGrapes=True)
     setDatatypeElephino('uint8', sourGrapes=True)
     setDatatypeLeavesTotal('uint8', sourGrapes=True)
-    inlineMapFoldingNumba(listCallablesAsStr)
+    listCallablesInline: List[str] = ['countInitialize', 'countParallel', 'countSequential']
+    callableDispatcher = 'doTheNeedful'
+    makeNumbaOptimizedFlow(listCallablesInline, callableDispatcher)
+    # makeNumbaOptimizedFlow(listCallablesInline)

syntheticModules/numbaInitialize.py → mapFolding/syntheticModules/numba_countInitialize.py

@@ -1,14 +1,11 @@
-import numpy
 from typing import Any, Tuple
-from numpy import integer
-from mapFolding import indexMy, indexTrack
+import numpy
+from numpy import dtype, integer, ndarray
 import numba
+from mapFolding import indexMy, indexTrack
 
-@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]]]):
+@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]
@@ -48,4 +45,4 @@ def countInitialize(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.d
             track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
             my[indexMy.leaf1ndex.value] += 1
         if my[indexMy.gap1ndex.value] > 0:
-            return
+            return

syntheticModules/numbaParallel.py → mapFolding/syntheticModules/numba_countParallel.py

@@ -1,11 +1,11 @@
+from mapFolding import indexMy, indexTrack
 from typing import Any, Tuple
-from numpy import integer
 import numpy
-from mapFolding import indexMy, indexTrack
+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]]]):
+@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()

syntheticModules/numbaSequential.py → mapFolding/syntheticModules/numba_countSequential.py

@@ -1,11 +1,11 @@
-from typing import Any, Tuple
-from numpy import integer
 import numpy
-from mapFolding import indexMy, indexTrack
+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]]]):
+@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]

mapFolding/syntheticModules/numba_doTheNeedful.py

@@ -0,0 +1,30 @@
+from mapFolding import indexMy, indexTrack
+from numpy import dtype, integer, ndarray
+from typing import Any, Tuple
+import numba
+import numpy
+from mapFolding.syntheticModules.numba_countInitialize import countInitialize
+from mapFolding.syntheticModules.numba_countParallel import countParallel
+from mapFolding.syntheticModules.numba_countSequential import countSequential
+
+@numba.jit((numba.uint8[:, :, ::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _nrt=True, boundscheck=True, cache=True, error_model='python', fastmath=False, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
+def doTheNeedful(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], mapShape: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
+    """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."""
+    countInitialize(connectionGraph, gapsWhere, my, track)
+    if my[indexMy.taskDivisions.value] > 0:
+        countParallel(connectionGraph, foldGroups, gapsWhere, my, track)
+    else:
+        countSequential(connectionGraph, foldGroups, gapsWhere, my, track)