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

{someAssemblyRequired → mapFolding/someAssemblyRequired}/synthesizeModulesNumba.py

@@ -1,13 +1,32 @@
-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,
+    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)`
@@ -53,8 +72,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):
@@ -83,6 +102,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 +111,7 @@ def decorateCallableWithNumba(astCallable: ast.FunctionDef, parallel: bool=False
 
     Returns
     -------
+
     ast.FunctionDef
         The modified AST function definition node with added Numba decorators.
 
@@ -171,7 +192,7 @@ def decorateCallableWithNumba(astCallable: ast.FunctionDef, parallel: bool=False
 
     astArgsNumbaSignature = ast.Tuple(elts=listNumbaParameterSignature, ctx=ast.Load())
 
-    if astCallable.name == 'countInitialize':
+    if astCallable.name == 'countInitialize' or astCallable.name == 'doTheNeedful':
         parametersNumba = {}
     else:
         parametersNumba = parametersNumbaDEFAULT if not parallel else ParametersNumba({**parametersNumbaDEFAULT, 'parallel': True})
@@ -289,7 +310,7 @@ 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.
 
@@ -343,104 +364,143 @@ 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:
+    """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.
+        """
 
-    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.
+    # Parse source code
+    sourceAST = ast.parse(codeSource)
 
-    Returns:
-        List[Tuple[pathlib.Path, str]]: List of tuples containing:
-            - Generated file paths
-            - Associated callable names
+    # 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)
 
-    Raises:
-        Exception: If inline operation fails during code generation.
+    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]
+
+    # Add Numba decorator
+    FunctionDefTarget = decorateCallableWithNumba(FunctionDefTarget, parallel=False)
+    FunctionDefTarget.body.insert(0, ast.Expr(value=ast.Constant(value=docstringDispatcherNumba)))
+
+    # Combine everything into a module
+    moduleAST = ast.Module(
+        body=cast(List[ast.stmt]
+                , importsAST
+                + [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)
+
+def makeNumbaOptimizedFlow(listCallablesInline: List[str], callableDispatcher: Optional[str] = None, algorithmSource: Optional[ModuleType] = None):
+    """Synthesizes numba-optimized versions of map folding functions."""
 
-    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
-    """
     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!")
+
+        pathFilename = getPathFilenameWrite(callableTarget)
+        astImport = makeAstImport(callableTarget)
 
-    # TODO abstract this process
-    # especially remove the hardcoded paths and filenames
+        listStuffYouOughtaKnow.append(youOughtaKnow(
+            callableSynthesized=callableTarget,
+            pathFilenameForMe=pathFilename,
+            astForCompetentProgrammers=astImport
+        ))
+        pathFilename.write_text(moduleSource)
 
-    for callableTarget in listCallablesAsStr:
+    # 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)

mapFolding/syntheticModules/__init__.py

@@ -0,0 +1,3 @@
+from .numba_countInitialize import countInitialize
+from .numba_countParallel import countParallel
+from .numba_countSequential import countSequential

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

@@ -1,14 +1,12 @@
+from numpy.typing import NDArray
 import numpy
-from typing import Any, Tuple
 from numpy import integer
-from mapFolding import indexMy, indexTrack
 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]]]):
+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:
     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 +46,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,12 @@
-from typing import Any, Tuple
-from numpy import integer
+from numpy.typing import NDArray
 import numpy
-from mapFolding import indexMy, indexTrack
+from numpy import integer
 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=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]]]):
+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:
     gapsWherePARALLEL = gapsWhere.copy()
     myPARALLEL = my.copy()
     trackPARALLEL = track.copy()

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

@@ -1,11 +1,12 @@
-from typing import Any, Tuple
-from numpy import integer
+from numpy.typing import NDArray
 import numpy
-from mapFolding import indexMy, indexTrack
+from numpy import integer
 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]]]):
+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:
     leafBelow = track[indexTrack.leafBelow.value]
     gapRangeStart = track[indexTrack.gapRangeStart.value]
     countDimensionsGapped = track[indexTrack.countDimensionsGapped.value]

mapFolding/syntheticModules/numba_doTheNeedful.py

@@ -0,0 +1,33 @@
+from mapFolding import indexMy, indexTrack
+from numpy import integer
+from numpy.typing import 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]))
+def doTheNeedful(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]]]) -> 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)

mapFolding/theDao.py

@@ -0,0 +1,214 @@
+from mapFolding import indexMy, indexTrack
+from numpy import integer
+from numpy.typing import NDArray
+from typing import Any, Tuple
+import numba
+import numpy
+
+def activeGapIncrement(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+    my[indexMy.gap1ndex.value] += 1
+
+def activeLeafGreaterThan0Condition(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+    return my[indexMy.leaf1ndex.value]
+
+def activeLeafGreaterThanLeavesTotalCondition(foldGroups: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+    return my[indexMy.leaf1ndex.value] > foldGroups[-1]
+
+def activeLeafIsTheFirstLeafCondition(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+    return my[indexMy.leaf1ndex.value] <= 1
+
+def allDimensionsAreUnconstrained(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+    return not my[indexMy.dimensionsUnconstrained.value]
+
+def backtrack(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> None:
+    my[indexMy.leaf1ndex.value] -= 1
+    track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]
+    track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]
+
+def backtrackCondition(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> Any:
+    return my[indexMy.leaf1ndex.value] and my[indexMy.gap1ndex.value] == track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
+
+def gap1ndexCeilingIncrement(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+    my[indexMy.gap1ndexCeiling.value] += 1
+
+def countGaps(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:
+    gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.leafConnectee.value]
+    if track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] == 0:
+        gap1ndexCeilingIncrement(my=my)
+    track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
+
+def dimension1ndexIncrement(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+    my[indexMy.indexDimension.value] += 1
+
+def dimensionsUnconstrainedCondition(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+    return connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]
+
+def dimensionsUnconstrainedDecrement(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+    my[indexMy.dimensionsUnconstrained.value] -= 1
+
+def filterCommonGaps(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:
+    gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
+    if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsUnconstrained.value]:
+        activeGapIncrement(my=my)
+    track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
+
+def findGapsInitializeVariables(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> None:
+    my[indexMy.dimensionsUnconstrained.value] = my[indexMy.dimensionsTotal.value]
+    my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
+    my[indexMy.indexDimension.value] = 0
+
+def indexMiniGapIncrement(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+    my[indexMy.indexMiniGap.value] += 1
+
+def indexMiniGapInitialization(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+    my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
+
+def insertUnconstrainedLeaf(gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+    my[indexMy.indexLeaf.value] = 0
+    while my[indexMy.indexLeaf.value] < my[indexMy.leaf1ndex.value]:
+        gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.indexLeaf.value]
+        my[indexMy.gap1ndexCeiling.value] += 1
+        my[indexMy.indexLeaf.value] += 1
+
+def leafBelowSentinelIs1Condition(track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> Any:
+    return track[indexTrack.leafBelow.value, 0] == 1
+
+def leafConnecteeInitialization(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+    my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
+
+def leafConnecteeUpdate(connectionGraph: numpy.ndarray[Tuple[int, int, 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:
+    my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
+
+def loopingLeavesConnectedToActiveLeaf(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+    return my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]
+
+def loopingTheDimensions(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+    return my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]
+
+def loopingToActiveGapCeiling(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+    return my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]
+
+def placeLeaf(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:
+    my[indexMy.gap1ndex.value] -= 1
+    track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]] = gapsWhere[my[indexMy.gap1ndex.value]]
+    track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]] = track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]]
+    track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
+    track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
+    track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
+    my[indexMy.leaf1ndex.value] += 1
+
+def placeLeafCondition(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+    return my[indexMy.leaf1ndex.value]
+
+def thereAreComputationDivisionsYouMightSkip(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+    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: 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:
+    while activeLeafGreaterThan0Condition(my=my):
+        if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
+            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)
+            if allDimensionsAreUnconstrained(my=my):
+                insertUnconstrainedLeaf(gapsWhere=gapsWhere, my=my)
+            indexMiniGapInitialization(my=my)
+            while loopingToActiveGapCeiling(my=my):
+                filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
+                indexMiniGapIncrement(my=my)
+        if placeLeafCondition(my=my):
+            placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
+        if my[indexMy.gap1ndex.value] > 0:
+            return
+
+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:
+    gapsWherePARALLEL = gapsWhere.copy()
+    myPARALLEL = my.copy()
+    trackPARALLEL = track.copy()
+    taskDivisionsPrange = myPARALLEL[indexMy.taskDivisions.value]
+    for indexSherpa in numba.prange(taskDivisionsPrange):
+        groupsOfFolds: int = 0
+        gapsWhere = gapsWherePARALLEL.copy()
+        my = myPARALLEL.copy()
+        my[indexMy.taskIndex.value] = indexSherpa
+        track = trackPARALLEL.copy()
+        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):
+                        if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
+                            dimensionsUnconstrainedDecrement(my=my)
+                        else:
+                            leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
+                            while loopingLeavesConnectedToActiveLeaf(my=my):
+                                if thereAreComputationDivisionsYouMightSkip(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)
+            while backtrackCondition(my=my, track=track):
+                backtrack(my=my, track=track)
+            if placeLeafCondition(my=my):
+                placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
+        foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
+
+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:
+    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)
+        while backtrackCondition(my=my, track=track):
+            backtrack(my=my, track=track)
+        if placeLeafCondition(my=my):
+            placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
+    foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
+
+def doTheNeedful(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]]]
+                ) -> None:
+    countInitialize(connectionGraph, gapsWhere, my, track)
+
+    if my[indexMy.taskDivisions.value] > 0:
+        countParallel(connectionGraph, foldGroups, gapsWhere, my, track)
+    else:
+        countSequential(connectionGraph, foldGroups, gapsWhere, my, track)