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

mapFolding/someAssemblyRequired/synthesizeNumbaHardcoding.py

@@ -0,0 +1,188 @@
+from synthesizeNumba import *
+
+def makeNumbaOptimizedFlow(listCallablesInline: List[str], callableDispatcher: Optional[str] = None, algorithmSource: Optional[ModuleType] = None) -> None:
+    if not algorithmSource:
+        algorithmSource = getAlgorithmSource()
+
+    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:
+        pythonSource = inspect.getsource(algorithmSource)
+        parametersNumba = None
+        unpackArrays = False
+        match callableTarget:
+            case 'countParallel':
+                parametersNumba = parametersNumbaSuperJitParallel
+            case 'countSequential':
+                parametersNumba = parametersNumbaSuperJit
+                unpackArrays = True
+            case 'countInitialize':
+                parametersNumba = parametersNumbaDEFAULT
+        pythonSource = inlineOneCallable(pythonSource, callableTarget, parametersNumba, unpackArrays)
+        if not pythonSource:
+            raise Exception("Pylance, OMG! The sky is falling!")
+
+        pathFilename = getPathFilenameWrite(callableTarget)
+
+        listStuffYouOughtaKnow.append(youOughtaKnow(
+            callableSynthesized=callableTarget,
+            pathFilenameForMe=pathFilename,
+            astForCompetentProgrammers=makeAstImport(callableTarget)
+        ))
+        pythonSource = autoflake.fix_code(pythonSource, ['mapFolding', 'numba', 'numpy'])
+        pathFilename.write_text(pythonSource)
+
+    # Generate dispatcher if requested
+    if callableDispatcher:
+        pythonSource = inspect.getsource(algorithmSource)
+        pythonSource = makeDispatcherNumba(pythonSource, callableDispatcher, listStuffYouOughtaKnow)
+        if not pythonSource:
+            raise FREAKOUT
+
+        pathFilename = getPathFilenameWrite(callableDispatcher)
+
+        listStuffYouOughtaKnow.append(youOughtaKnow(
+            callableSynthesized=callableDispatcher,
+            pathFilenameForMe=pathFilename,
+            astForCompetentProgrammers=makeAstImport(callableDispatcher)
+        ))
+        pythonSource = autoflake.fix_code(pythonSource, ['mapFolding', 'numba', 'numpy'])
+        pathFilename.write_text(pythonSource)
+
+def writeJobNumba(listDimensions: Sequence[int], callableTarget: str, algorithmSource: ModuleType, parametersNumba: Optional[ParametersNumba]=None, pathFilenameWriteJob: Optional[Union[str, os.PathLike[str]]] = None, **keywordArguments: Optional[Any]) -> pathlib.Path:
+    """ Parameters: **keywordArguments: most especially for `computationDivisions` if you want to make a parallel job. Also `CPUlimit`. """
+    """Notes about the existing logic:
+    - the synthesized module must run well as a standalone interpreted Python script
+    - `writeJobNumba` synthesizes a parameter-specific module by starting with code synthesized by `makeNumbaOptimizedFlow`, which improves the optimization
+    - similarly, `writeJobNumba` should be a solid foundation for more optimizations, most especially compiling to a standalone executable, but the details of the next optimization step are unknown
+    - the minimum runtime (on my computer) to compute a value unknown to mathematicians is 26 hours, therefore, we ant to ensure the value is seen by the user, but we must have ultra-light overhead.
+    - perf_counter is for testing. When I run a real job, I delete those lines
+    - avoid `with` statement
+    """
+    stateJob = makeStateJob(listDimensions, writeJob=False, **keywordArguments)
+    pythonSource = inspect.getsource(algorithmSource)
+    astModule = ast.parse(pythonSource)
+
+    allImports = UniversalImportTracker()
+
+    for statement in astModule.body:
+        if isinstance(statement, (ast.Import, ast.ImportFrom)):
+            allImports.addAst(statement)
+
+    FunctionDefTarget = next((node for node in astModule.body if isinstance(node, ast.FunctionDef) and node.name == callableTarget), None)
+    if not FunctionDefTarget: raise ValueError(f"I received `{callableTarget=}` and {algorithmSource.__name__=}, but I could not find that function in that source.")
+
+    for pirateScowl in FunctionDefTarget.args.args.copy():
+        match pirateScowl.arg:
+            case 'my':
+                FunctionDefTarget, allImports = evaluate_argIn_body(FunctionDefTarget, pirateScowl, stateJob[pirateScowl.arg], ['taskIndex', 'dimensionsTotal'], allImports)
+            case 'track':
+                FunctionDefTarget, allImports = evaluateArrayIn_body(FunctionDefTarget, pirateScowl, stateJob[pirateScowl.arg], allImports)
+            # TODO remove this after implementing `unrollWhileLoop`
+            case 'connectionGraph':
+                FunctionDefTarget, allImports = moveArrayTo_body(FunctionDefTarget, pirateScowl, stateJob[pirateScowl.arg], allImports)
+            case 'gapsWhere':
+                FunctionDefTarget, allImports = moveArrayTo_body(FunctionDefTarget, pirateScowl, stateJob[pirateScowl.arg], allImports)
+            case 'foldGroups':
+                FunctionDefTarget = removeIdentifierFrom_body(FunctionDefTarget, pirateScowl)
+
+    # Move function parameters to the function body,
+    # initialize identifiers with their state types and values,
+    # and replace static-valued identifiers with their values.
+    FunctionDefTarget, allImports = evaluateAnnAssignIn_body(FunctionDefTarget, allImports)
+    FunctionDefTarget = astNameToAstConstant(FunctionDefTarget, 'dimensionsTotal', int(stateJob['my'][indexMy.dimensionsTotal]))
+    FunctionDefTarget = astObjectToAstConstant(FunctionDefTarget, 'foldGroups[-1]', int(stateJob['foldGroups'][-1]))
+
+    FunctionDefTarget = unrollWhileLoop(FunctionDefTarget, 'indexDimension', stateJob['my'][indexMy.dimensionsTotal], stateJob['connectionGraph'])
+
+    FunctionDefTarget, allImports = addReturnJobNumba(FunctionDefTarget, stateJob, allImports)
+    FunctionDefTarget, allImports = makeDecoratorJobNumba(FunctionDefTarget, allImports, parametersNumba)
+
+    pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateJob['mapShape'])
+    # TODO consider: 1) launcher is a function, 2) if __name__ calls the launcher function, and 3) the launcher is "jitted", even just a light jit, then 4) `FunctionDefTarget` could be superJit.
+    astLauncher = makeLauncherJobNumba(FunctionDefTarget.name, pathFilenameFoldsTotal)
+
+    astImports = allImports.makeListAst()
+
+    astModule = ast.Module(body=cast(List[ast.stmt], astImports + [FunctionDefTarget] + [astLauncher]), type_ignores=[])
+    ast.fix_missing_locations(astModule)
+
+    pythonSource = ast.unparse(astModule)
+    pythonSource = autoflake.fix_code(pythonSource, ['mapFolding', 'numba', 'numpy'])
+
+    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(pythonSource)
+    return pathFilenameWriteJob
+
+def mainBig():
+    setDatatypeModule('numpy', sourGrapes=True)
+    setDatatypeFoldsTotal('int64', sourGrapes=True)
+    setDatatypeElephino('uint8', sourGrapes=True)
+    setDatatypeLeavesTotal('uint8', sourGrapes=True)
+    listCallablesInline: List[str] = ['countInitialize', 'countParallel', 'countSequential']
+    Z0Z_setDatatypeModuleScalar('numba')
+    Z0Z_setDecoratorCallable('jit')
+    callableDispatcher = 'doTheNeedful'
+    makeNumbaOptimizedFlow(listCallablesInline, callableDispatcher)
+
+def mainSmall():
+    listDimensions = [6,6]
+    setDatatypeFoldsTotal('int64', sourGrapes=True)
+    setDatatypeElephino('uint8', sourGrapes=True)
+    setDatatypeLeavesTotal('uint8', sourGrapes=True)
+    from mapFolding.syntheticModules import numba_countSequential
+    algorithmSource: ModuleType = numba_countSequential
+    Z0Z_setDatatypeModuleScalar('numba')
+    Z0Z_setDecoratorCallable('jit')
+    writeJobNumba(listDimensions, 'countSequential', algorithmSource, parametersNumbaDEFAULT)
+
+if __name__ == '__main__':
+    mainBig()
+
+    mainSmall()

mapFolding/syntheticModules/numba_countInitialize.py

@@ -1,10 +1,14 @@
-from typing import Any, Tuple
-import numpy
-from numpy import dtype, integer, ndarray
-import numba
-from mapFolding import indexMy, indexTrack
+from mapFolding import indexTrack
+from mapFolding import indexMy
+from numba import uint8
+from numba import jit
+from numpy import ndarray
+from numpy import dtype
+from numpy import integer
+from typing import Any
+from typing import Tuple
 
-@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)
+@jit((uint8[:, :, ::1], uint8[::1], uint8[::1], 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:

mapFolding/syntheticModules/numba_countParallel.py

@@ -1,21 +1,27 @@
-from mapFolding import indexMy, indexTrack
-from typing import Any, Tuple
-import numpy
-from numpy import dtype, integer, ndarray
-import numba
+from mapFolding import indexTrack
+from mapFolding import indexMy
+from numba import uint8
+from numba import jit
+from numba import int64
+from numba import prange
+from numpy import ndarray
+from numpy import dtype
+from numpy import integer
+from typing import Any
+from typing import 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=True, inline='always', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=True)
+@jit((uint8[:, :, ::1], int64[::1], uint8[::1], uint8[::1], 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()
     taskDivisionsPrange = myPARALLEL[indexMy.taskDivisions.value]
-    for indexSherpa in numba.prange(taskDivisionsPrange):
+    for indexSherpa in prange(taskDivisionsPrange):
         groupsOfFolds: int = 0
         gapsWhere = gapsWherePARALLEL.copy()
         my = myPARALLEL.copy()
-        my[indexMy.taskIndex.value] = indexSherpa
         track = trackPARALLEL.copy()
+        my[indexMy.taskIndex.value] = indexSherpa
         while my[indexMy.leaf1ndex.value]:
             if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
                 if my[indexMy.leaf1ndex.value] > foldGroups[-1]:

mapFolding/syntheticModules/numba_countSequential.py

@@ -1,10 +1,15 @@
-import numpy
-from numpy import dtype, integer, ndarray
-import numba
-from mapFolding import indexMy, indexTrack
-from typing import Any, Tuple
+from mapFolding import indexTrack
+from mapFolding import indexMy
+from numba import uint8
+from numba import jit
+from numba import int64
+from numpy import ndarray
+from numpy import dtype
+from numpy import integer
+from typing import Any
+from typing import 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=True, inline='always', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=False)
+@jit((uint8[:, :, ::1], int64[::1], uint8[::1], uint8[::1], 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]
@@ -20,33 +25,33 @@ def countSequential(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer
     gap1ndex = my[indexMy.gap1ndex.value]
     taskIndex = my[indexMy.taskIndex.value]
     groupsOfFolds: int = 0
-    doFindGaps = True
     while leaf1ndex:
-        if (doFindGaps := (leaf1ndex <= 1 or leafBelow[0] == 1)) and leaf1ndex > foldGroups[-1]:
-            groupsOfFolds += 1
-        elif doFindGaps:
-            dimensionsUnconstrained = dimensionsTotal
-            gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
-            indexDimension = 0
-            while indexDimension < dimensionsTotal:
-                if connectionGraph[indexDimension, leaf1ndex, leaf1ndex] == leaf1ndex:
-                    dimensionsUnconstrained -= 1
-                else:
-                    leafConnectee = connectionGraph[indexDimension, leaf1ndex, leaf1ndex]
-                    while leafConnectee != leaf1ndex:
-                        gapsWhere[gap1ndexCeiling] = leafConnectee
-                        if countDimensionsGapped[leafConnectee] == 0:
-                            gap1ndexCeiling += 1
-                        countDimensionsGapped[leafConnectee] += 1
-                        leafConnectee = connectionGraph[indexDimension, leaf1ndex, leafBelow[leafConnectee]]
-                indexDimension += 1
-            indexMiniGap = gap1ndex
-            while indexMiniGap < gap1ndexCeiling:
-                gapsWhere[gap1ndex] = gapsWhere[indexMiniGap]
-                if countDimensionsGapped[gapsWhere[indexMiniGap]] == dimensionsUnconstrained:
-                    gap1ndex += 1
-                countDimensionsGapped[gapsWhere[indexMiniGap]] = 0
-                indexMiniGap += 1
+        if leaf1ndex <= 1 or leafBelow[0] == 1:
+            if leaf1ndex > foldGroups[-1]:
+                groupsOfFolds += 1
+            else:
+                dimensionsUnconstrained = dimensionsTotal
+                gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
+                indexDimension = 0
+                while indexDimension < dimensionsTotal:
+                    if connectionGraph[indexDimension, leaf1ndex, leaf1ndex] == leaf1ndex:
+                        dimensionsUnconstrained -= 1
+                    else:
+                        leafConnectee = connectionGraph[indexDimension, leaf1ndex, leaf1ndex]
+                        while leafConnectee != leaf1ndex:
+                            gapsWhere[gap1ndexCeiling] = leafConnectee
+                            if countDimensionsGapped[leafConnectee] == 0:
+                                gap1ndexCeiling += 1
+                            countDimensionsGapped[leafConnectee] += 1
+                            leafConnectee = connectionGraph[indexDimension, leaf1ndex, leafBelow[leafConnectee]]
+                    indexDimension += 1
+                indexMiniGap = gap1ndex
+                while indexMiniGap < gap1ndexCeiling:
+                    gapsWhere[gap1ndex] = gapsWhere[indexMiniGap]
+                    if countDimensionsGapped[gapsWhere[indexMiniGap]] == dimensionsUnconstrained:
+                        gap1ndex += 1
+                    countDimensionsGapped[gapsWhere[indexMiniGap]] = 0
+                    indexMiniGap += 1
         while leaf1ndex and gap1ndex == gapRangeStart[leaf1ndex - 1]:
             leaf1ndex -= 1
             leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]

mapFolding/syntheticModules/numba_doTheNeedful.py

@@ -1,28 +1,18 @@
-from mapFolding import indexMy, indexTrack
-from numpy import dtype, integer, ndarray
-from typing import Any, Tuple
-import numba
-import numpy
+from mapFolding import indexMy
+from numba import uint8
+from numba import jit
+from numba import int64
+from numpy import ndarray
+from numpy import dtype
+from numpy import integer
+from typing import Any
+from typing import Tuple
 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)
+@jit((uint8[:, :, ::1], int64[::1], uint8[::1], uint8[::1], uint8[::1], 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)

mapFolding/theDao.py

@@ -1,10 +1,10 @@
 from mapFolding import indexMy, indexTrack
+from numba import prange
 from numpy import dtype, integer, ndarray
 from typing import Any, Tuple
-import numba
-import numpy
 
 def activeGapIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+    # `.value` is not necessary for this module or most modules. But, this module is transformed into Numba "jitted" functions, and Numba won't use `Enum` for an index without `.value`.
     my[indexMy.gap1ndex.value] += 1
 
 def activeLeafGreaterThan0Condition(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
@@ -36,9 +36,6 @@ def countGaps(gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[T
         gap1ndexCeilingIncrement(my=my)
     track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
 
-def dimension1ndexIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
-    my[indexMy.indexDimension.value] += 1
-
 def dimensionsUnconstrainedCondition(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
     return connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]
 
@@ -56,6 +53,9 @@ def findGapsInitializeVariables(my: ndarray[Tuple[int], dtype[integer[Any]]], tr
     my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
     my[indexMy.indexDimension.value] = 0
 
+def indexDimensionIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+    my[indexMy.indexDimension.value] += 1
+
 def indexMiniGapIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
     my[indexMy.indexMiniGap.value] += 1
 
@@ -81,7 +81,7 @@ def leafConnecteeUpdate(connectionGraph: ndarray[Tuple[int, int, int], dtype[int
 def loopingLeavesConnectedToActiveLeaf(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
     return my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]
 
-def loopingTheDimensions(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def loopUpToDimensionsTotal(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
     return my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]
 
 def loopingToActiveGapCeiling(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
@@ -103,13 +103,15 @@ def thereAreComputationDivisionsYouMightSkip(my: ndarray[Tuple[int], dtype[integ
     return my[indexMy.leaf1ndex.value] != my[indexMy.taskDivisions.value] or my[indexMy.leafConnectee.value] % my[indexMy.taskDivisions.value] == my[indexMy.taskIndex.value]
 
 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:
+                        , gapsWhere: ndarray[Tuple[int]          , dtype[integer[Any]]]
+                        ,        my: ndarray[Tuple[int]          , dtype[integer[Any]]]
+                        ,     track: ndarray[Tuple[int, int]     , dtype[integer[Any]]]
+                    ) -> None:
+
     while activeLeafGreaterThan0Condition(my=my):
         if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
             findGapsInitializeVariables(my=my, track=track)
-            while loopingTheDimensions(my=my):
+            while loopUpToDimensionsTotal(my=my):
                 if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
                     dimensionsUnconstrainedDecrement(my=my)
                 else:
@@ -117,7 +119,7 @@ def countInitialize(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer
                     while loopingLeavesConnectedToActiveLeaf(my=my):
                         countGaps(gapsWhere=gapsWhere, my=my, track=track)
                         leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
-                dimension1ndexIncrement(my=my)
+                indexDimensionIncrement(my=my)
             if allDimensionsAreUnconstrained(my=my):
                 insertUnconstrainedLeaf(gapsWhere=gapsWhere, my=my)
             indexMiniGapInitialization(my=my)
@@ -130,27 +132,34 @@ def countInitialize(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer
             return
 
 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:
+                    ,  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()
+
     taskDivisionsPrange = myPARALLEL[indexMy.taskDivisions.value]
-    for indexSherpa in numba.prange(taskDivisionsPrange):
+
+    for indexSherpa in prange(taskDivisionsPrange):
         groupsOfFolds: int = 0
+
         gapsWhere = gapsWherePARALLEL.copy()
         my = myPARALLEL.copy()
-        my[indexMy.taskIndex.value] = indexSherpa
         track = trackPARALLEL.copy()
+
+        my[indexMy.taskIndex.value] = indexSherpa
+
         while activeLeafGreaterThan0Condition(my=my):
             if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
                 if activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my):
                     groupsOfFolds += 1
                 else:
                     findGapsInitializeVariables(my=my, track=track)
-                    while loopingTheDimensions(my=my):
+                    while loopUpToDimensionsTotal(my=my):
                         if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
                             dimensionsUnconstrainedDecrement(my=my)
                         else:
@@ -159,7 +168,7 @@ def countParallel(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[A
                                 if thereAreComputationDivisionsYouMightSkip(my=my):
                                     countGaps(gapsWhere=gapsWhere, my=my, track=track)
                                 leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
-                        dimension1ndexIncrement(my=my)
+                        indexDimensionIncrement(my=my)
                     indexMiniGapInitialization(my=my)
                     while loopingToActiveGapCeiling(my=my):
                         filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
@@ -170,28 +179,34 @@ def countParallel(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[A
                 placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
         foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
 
-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:
+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:
+
     groupsOfFolds: int = 0
-    doFindGaps = True
+
     while activeLeafGreaterThan0Condition(my=my):
-        if ((doFindGaps := activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track))
-                and activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my)):
-            groupsOfFolds += 1
-        elif doFindGaps:
-            findGapsInitializeVariables(my=my, track=track)
-            while loopingTheDimensions(my=my):
-                if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
-                    dimensionsUnconstrainedDecrement(my=my)
-                else:
-                    leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
-                    while loopingLeavesConnectedToActiveLeaf(my=my):
-                        countGaps(gapsWhere=gapsWhere, my=my, track=track)
-                        leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
-                dimension1ndexIncrement(my=my)
-            indexMiniGapInitialization(my=my)
-            while loopingToActiveGapCeiling(my=my):
-                filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
-                indexMiniGapIncrement(my=my)
+        if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
+            if activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my):
+                groupsOfFolds += 1
+            else:
+                findGapsInitializeVariables(my=my, track=track)
+                while loopUpToDimensionsTotal(my=my):
+                    if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
+                        dimensionsUnconstrainedDecrement(my=my)
+                    else:
+                        leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
+                        while loopingLeavesConnectedToActiveLeaf(my=my):
+                            countGaps(gapsWhere=gapsWhere, my=my, track=track)
+                            leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
+                    indexDimensionIncrement(my=my)
+                indexMiniGapInitialization(my=my)
+                while loopingToActiveGapCeiling(my=my):
+                    filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
+                    indexMiniGapIncrement(my=my)
         while backtrackCondition(my=my, track=track):
             backtrack(my=my, track=track)
         if placeLeafCondition(my=my):
@@ -199,12 +214,13 @@ def countSequential(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer
     foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
 
 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:
+                    , 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:
+
     countInitialize(connectionGraph, gapsWhere, my, track)
 
     if my[indexMy.taskDivisions.value] > 0:

mapFolding/theSSOT.py

@@ -1,6 +1,6 @@
 from collections import defaultdict
 from mapFolding.theSSOTnumba import *
-from numpy import integer
+from numpy import dtype, integer, ndarray
 from types import ModuleType
 from typing import Any, Callable, Dict, Final, Optional, Tuple, Type, TYPE_CHECKING, cast
 import enum
@@ -73,14 +73,14 @@ def getDispatcherCallable() -> Callable[..., None]:
     from mapFolding.syntheticModules import numba_doTheNeedful
     return cast(Callable[..., None], numba_doTheNeedful.doTheNeedful)
 
-# NOTE I want this _concept_ to be well implemented and usable everywhere: Python, Numba, Jax, CUDA, idc
+# NOTE I want this _concept_, not necessarily this method, to be well implemented and usable everywhere: Python, Numba, Jax, CUDA, idc
 class computationState(TypedDict):
-    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]]]
-    mapShape: 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]]]
+    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]]]
 
 @enum.verify(enum.CONTINUOUS, enum.UNIQUE) if sys.version_info >= (3, 11) else lambda x: x
 class EnumIndices(enum.IntEnum):
@@ -249,3 +249,27 @@ def hackSSOTdatatype(identifier: str) -> str:
     elif RubeGoldBerg == 'datatypeLeavesTotal':
         return _get_datatype('leavesTotal')
     raise Exception("Dude, you forgot to set a value in `hackSSOTdatatype`.")
+
+_datatypeModuleScalar = 'numba'
+_decoratorCallable = 'jit'
+def Z0Z_getDatatypeModuleScalar() -> str:
+    return _datatypeModuleScalar
+
+def Z0Z_setDatatypeModuleScalar(moduleName: str) -> str:
+    global _datatypeModuleScalar
+    _datatypeModuleScalar = moduleName
+    return _datatypeModuleScalar
+
+def Z0Z_getDecoratorCallable() -> str:
+    return _decoratorCallable
+
+def Z0Z_setDecoratorCallable(decoratorName: str) -> str:
+    global _decoratorCallable
+    _decoratorCallable = decoratorName
+    return _decoratorCallable
+
+class FREAKOUT(Exception):
+    pass
+
+# This identifier is declared in theDao.py. Two sources of truth is better than 900.
+Z0Z_identifierCountFolds = 'groupsOfFolds'

mapFolding/theSSOTnumba.py

@@ -1,3 +1,4 @@
+"""I have so much truth, I need two files to contain it all!"""
 """TODO learn how to use this efficiently and effectively to solve problems, be DRY, and have SSOT."""
 from typing import Final, TYPE_CHECKING, Dict, Any, Union, Callable, Tuple, Any
 import numba
@@ -33,7 +34,7 @@ Old notes that are not entirely accurate.
 | `no_cpython_wrapper`    | Disable Python C-API wrapper generation             | Size                  | Smallest        | Exclusionary             |
 
 """
-
+# NOTE Deepseek removed forceinline=True, inline='always'
 # TODO try to implement all possible parameters, but use `NotRequired` for the more esoteric ones
 class ParametersNumba(TypedDict):
     _dbg_extend_lifetimes: NotRequired[bool]