mapFolding 0.6.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

mapFolding/someAssemblyRequired/whatWillBe.py

@@ -0,0 +1,311 @@
+"""
+- Settings for synthesizing the modules used by the package (i.e., the flow for numba)
+- Settings for synthesizing modules that could be used by the package (e.g., the flow for JAX)
+- Therefore, an abstracted system for creating settings for the package
+- And with only a little more effort, an abstracted system for creating settings to synthesize arbitrary subsets of modules for arbitrary packages
+"""
+from mapFolding.someAssemblyRequired.transformationTools import *
+from mapFolding.theSSOT import (
+	FREAKOUT,
+	getDatatypePackage,
+	getSourceAlgorithm,
+	theDataclassIdentifierAsStr,
+	theDataclassInstanceAsStr,
+	theDispatcherCallableAsStr,
+	theFileExtension,
+	theFormatStrModuleForCallableSynthetic,
+	theFormatStrModuleSynthetic,
+	theLogicalPathModuleDataclass,
+	theLogicalPathModuleDispatcherSynthetic,
+	theModuleOfSyntheticModules,
+	thePackageName,
+	thePathPackage,
+	Z0Z_sequentialCallableAsStr,
+)
+from autoflake import fix_code as autoflake_fix_code
+from collections import defaultdict
+from collections.abc import Sequence
+from inspect import getsource as inspect_getsource
+from mapFolding.someAssemblyRequired.ingredientsNumba import parametersNumbaDEFAULT, parametersNumbaSuperJit, parametersNumbaSuperJitParallel, ParametersNumba
+from pathlib import Path
+from types import ModuleType
+from typing import NamedTuple
+from Z0Z_tools import updateExtendPolishDictionaryLists
+import ast
+import dataclasses
+
+"""
+Start with what is: theDao.py
+Create settings that can transform into what I or the user want it to be.
+
+The simplest flow with numba is:
+1. one module
+2. dispatcher
+	- initialize data with makeJob
+	- smash dataclass
+	- call countSequential
+3. countSequential
+	- jitted, not super-jitted
+	- functions inlined (or I'd have to jit them)
+	- return groupsOfFolds
+4. recycle the dataclass with groupsOfFolds
+5. return the dataclass
+"""
+
+@dataclasses.dataclass
+class RecipeSynthesizeFlow:
+	"""Settings for synthesizing flow."""
+	# TODO consider `IngredientsFlow` or similar
+	sourceAlgorithm: ModuleType = getSourceAlgorithm()
+	sourcePython: str = inspect_getsource(sourceAlgorithm)
+	# sourcePython: str = inspect_getsource(self.sourceAlgorithm)
+	# "self" is not defined
+	# I still hate the OOP paradigm. But I like this dataclass stuff.
+	source_astModule: ast.Module = ast.parse(sourcePython)
+
+	# ========================================
+	# Filesystem
+	pathPackage: Path = thePathPackage
+	fileExtension: str = theFileExtension
+
+	# ========================================
+	# Logical identifiers
+	# meta
+	formatStrModuleSynthetic: str = theFormatStrModuleSynthetic
+	formatStrModuleForCallableSynthetic: str = theFormatStrModuleForCallableSynthetic
+
+	# Package
+	packageName: ast_Identifier = thePackageName
+
+	# Module
+	moduleOfSyntheticModules: str = theModuleOfSyntheticModules
+	logicalPathModuleDataclass: str = theLogicalPathModuleDataclass
+	logicalPathModuleDispatcher: str = theLogicalPathModuleDispatcherSynthetic
+	dataConverterModule: str = 'dataNamespaceFlattened'
+
+	# Function
+	dataclassIdentifierAsStr: str = theDataclassIdentifierAsStr
+	dispatcherCallableAsStr: str = theDispatcherCallableAsStr
+	dataConverterCallableAsStr: str = 'flattenData'
+	sequentialCallableAsStr: str = Z0Z_sequentialCallableAsStr
+
+	# Variable
+	dataclassInstanceAsStr: str = theDataclassInstanceAsStr
+
+class LedgerOfImports:
+	def __init__(self, startWith: ast.AST | None = None) -> None:
+		self.dictionaryImportFrom: dict[str, list[tuple[str, str | None]]] = defaultdict(list)
+		self.listImport: list[str] = []
+
+		if startWith:
+			self.walkThis(startWith)
+
+	def addAst(self, astImport_: ast.Import | ast.ImportFrom) -> None:
+		if not isinstance(astImport_, (ast.Import, ast.ImportFrom)): # pyright: ignore[reportUnnecessaryIsInstance]
+			raise ValueError(f"Expected ast.Import or ast.ImportFrom, got {type(astImport_)}")
+		if isinstance(astImport_, ast.Import):
+			for alias in astImport_.names:
+				self.listImport.append(alias.name)
+		else:
+			if astImport_.module is not None:
+				for alias in astImport_.names:
+					self.dictionaryImportFrom[astImport_.module].append((alias.name, alias.asname))
+
+	def addImportStr(self, module: str) -> None:
+		self.listImport.append(module)
+
+	def addImportFromStr(self, module: str, name: str, asname: str | None = None) -> None:
+		self.dictionaryImportFrom[module].append((name, asname))
+
+	def makeListAst(self) -> list[ast.ImportFrom | ast.Import]:
+		listAstImportFrom: list[ast.ImportFrom] = []
+
+		for module, listOfNameTuples in sorted(self.dictionaryImportFrom.items()):
+			listOfNameTuples = sorted(list(set(listOfNameTuples)), key=lambda nameTuple: nameTuple[0])
+			listAlias: list[ast.alias] = []
+			for name, asname in listOfNameTuples:
+				listAlias.append(Make.astAlias(name, asname))
+			listAstImportFrom.append(Make.astImportFrom(module, listAlias))
+
+		listAstImport: list[ast.Import] = [Make.astImport(name) for name in sorted(set(self.listImport))]
+		return listAstImportFrom + listAstImport
+
+	def update(self, *fromLedger: 'LedgerOfImports') -> None:
+		"""
+		Update this ledger with imports from one or more other ledgers.
+
+		Parameters:
+			*fromTracker: One or more other `LedgerOfImports` objects from which to merge.
+		"""
+		self.dictionaryImportFrom = updateExtendPolishDictionaryLists(self.dictionaryImportFrom, *(ledger.dictionaryImportFrom for ledger in fromLedger), destroyDuplicates=True, reorderLists=True)
+
+		for ledger in fromLedger:
+			self.listImport.extend(ledger.listImport)
+
+	def walkThis(self, walkThis: ast.AST) -> None:
+		for smurf in ast.walk(walkThis):
+			if isinstance(smurf, (ast.Import, ast.ImportFrom)):
+				self.addAst(smurf)
+
+@dataclasses.dataclass
+class IngredientsFunction:
+	"""Everything necessary to integrate a function into a module should be here."""
+	FunctionDef: ast.FunctionDef # hint `Make.astFunctionDef`
+	imports: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
+
+@dataclasses.dataclass
+class IngredientsModule:
+	"""Everything necessary to create a module, including the package context, should be here."""
+	name: ast_Identifier
+	ingredientsFunction: dataclasses.InitVar[Sequence[IngredientsFunction] | IngredientsFunction | None] = None
+
+	imports: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
+	prologue: list[ast.stmt] = dataclasses.field(default_factory=list)
+	functions: list[ast.FunctionDef | ast.stmt] = dataclasses.field(default_factory=list)
+	epilogue: list[ast.stmt] = dataclasses.field(default_factory=list)
+	launcher: list[ast.stmt] = dataclasses.field(default_factory=list)
+
+	packageName: ast_Identifier | None= thePackageName
+	logicalPathINFIX: ast_Identifier | strDotStrCuzPyStoopid | None = None # module names other than the module itself and the package name
+	pathPackage: Path = thePathPackage
+	fileExtension: str = theFileExtension
+	type_ignores: list[ast.TypeIgnore] = dataclasses.field(default_factory=list)
+
+	def _getLogicalPathParent(self) -> str | None:
+		listModules: list[ast_Identifier] = []
+		if self.packageName:
+			listModules.append(self.packageName)
+		if self.logicalPathINFIX:
+			listModules.append(self.logicalPathINFIX)
+		if listModules:
+			return '.'.join(listModules)
+
+	def _getLogicalPathAbsolute(self) -> str:
+		listModules: list[ast_Identifier] = []
+		logicalPathParent: str | None = self._getLogicalPathParent()
+		if logicalPathParent:
+			listModules.append(logicalPathParent)
+		listModules.append(self.name)
+		return '.'.join(listModules)
+
+	@property
+	def pathFilename(self) -> Path:
+		pathRoot: Path = self.pathPackage
+		filename = self.name + self.fileExtension
+		if self.logicalPathINFIX:
+			whyIsThisStillAThing = self.logicalPathINFIX.split('.')
+			pathRoot = pathRoot.joinpath(*whyIsThisStillAThing)
+		return pathRoot.joinpath(filename)
+
+	@property
+	def absoluteImport(self) -> ast.Import:
+		return Make.astImport(self._getLogicalPathAbsolute())
+
+	@property
+	def absoluteImportFrom(self) -> ast.ImportFrom:
+		""" `from . import theModule` """
+		logicalPathParent: str | None = self._getLogicalPathParent()
+		if logicalPathParent is None:
+			logicalPathParent = '.'
+		return Make.astImportFrom(logicalPathParent, [Make.astAlias(self.name)])
+
+	def __post_init__(self, ingredientsFunction: Sequence[IngredientsFunction] | IngredientsFunction | None = None) -> None:
+		if ingredientsFunction is not None:
+			if isinstance(ingredientsFunction, IngredientsFunction):
+				self.addIngredientsFunction(ingredientsFunction)
+			else:
+				self.addIngredientsFunction(*ingredientsFunction)
+
+	def addIngredientsFunction(self, *ingredientsFunction: IngredientsFunction) -> None:
+		"""Add one or more `IngredientsFunction`. """
+		listLedgers: list[LedgerOfImports] = []
+		for definition in ingredientsFunction:
+			self.functions.append(definition.FunctionDef)
+			listLedgers.append(definition.imports)
+		self.imports.update(*listLedgers)
+
+	def _makeModuleBody(self) -> list[ast.stmt]:
+		"""Constructs the body of the module, including prologue, functions, epilogue, and launcher."""
+		body: list[ast.stmt] = []
+		body.extend(self.imports.makeListAst())
+		body.extend(self.prologue)
+		body.extend(self.functions)
+		body.extend(self.epilogue)
+		body.extend(self.launcher)
+		# TODO `launcher` must start with `if __name__ == '__main__':` and be indented
+		return body
+
+	def writeModule(self) -> None:
+		"""Writes the module to disk with proper imports and functions.
+
+		This method creates a proper AST module with imports and function definitions,
+		fixes missing locations, unpacks the AST to Python code, applies autoflake
+		to clean up imports, and writes the resulting code to the appropriate file.
+		"""
+		astModule = Make.astModule(body=self._makeModuleBody(), type_ignores=self.type_ignores)
+		ast.fix_missing_locations(astModule)
+		pythonSource: str = ast.unparse(astModule)
+		if not pythonSource: raise FREAKOUT
+		autoflake_additional_imports: list[str] = []
+		if self.packageName:
+			autoflake_additional_imports.append(self.packageName)
+		# TODO LedgerOfImports method: list of package names. autoflake_additional_imports.extend()
+		autoflake_additional_imports.append(getDatatypePackage())
+		pythonSource = autoflake_fix_code(pythonSource, autoflake_additional_imports, expand_star_imports=False, remove_all_unused_imports=False, remove_duplicate_keys = False, remove_unused_variables = False,)
+		self.pathFilename.write_text(pythonSource)
+
+@dataclasses.dataclass
+class RecipeSynthesizeCountingFunction:
+	"""Settings for synthesizing counting functions."""
+	ingredients: IngredientsFunction
+
+numbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()
+
+# https://github.com/hunterhogan/mapFolding/issues/3
+sequentialFunctionDef = extractFunctionDef(numbaFlow.sequentialCallableAsStr, numbaFlow.source_astModule)
+if sequentialFunctionDef is None: raise FREAKOUT
+
+numbaCountSequential = RecipeSynthesizeCountingFunction(IngredientsFunction(
+	FunctionDef=sequentialFunctionDef,
+	imports=LedgerOfImports(numbaFlow.source_astModule)
+))
+
+# the data converter and the dispatcher could be in the same module.
+
+Z0Z_autoflake_additional_imports: list[str] = []
+Z0Z_autoflake_additional_imports.append(thePackageName)
+
+class ParametersSynthesizeNumbaCallable(NamedTuple):
+	callableTarget: str
+	parametersNumba: ParametersNumba | None = None
+	inlineCallables: bool = False
+
+listNumbaCallableDispatchees: list[ParametersSynthesizeNumbaCallable] = [
+	ParametersSynthesizeNumbaCallable('countParallel', parametersNumbaSuperJitParallel, True),
+	ParametersSynthesizeNumbaCallable('countSequential', parametersNumbaSuperJit, True),
+	ParametersSynthesizeNumbaCallable('countInitialize', parametersNumbaDEFAULT, True),
+]
+
+_datatypeModuleScalar = ''
+_decoratorCallable = ''
+
+# if numba
+_datatypeModuleScalar = 'numba'
+_decoratorCallable = 'jit'
+Z0Z_autoflake_additional_imports.append('numba')
+
+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

mapFolding/syntheticModules/dataNamespaceFlattened.py

@@ -0,0 +1,30 @@
+from mapFolding.someAssemblyRequired.synthesizeDataConverters import makeStateJob
+from mapFolding.syntheticModules.numbaCount_doTheNeedful import doTheNeedful
+from mapFolding.theSSOT import Array1DElephino, Array1DFoldsTotal, Array1DLeavesTotal, Array3D, ComputationState, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
+
+def flattenData(state: ComputationState) -> ComputationState:
+    state = makeStateJob(state.mapShape, writeJob=False)
+    mapShape: tuple[DatatypeLeavesTotal, ...] = state.mapShape
+    leavesTotal: DatatypeLeavesTotal = state.leavesTotal
+    taskDivisions: DatatypeLeavesTotal = state.taskDivisions
+    connectionGraph: Array3D = state.connectionGraph
+    dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
+    countDimensionsGapped: Array1DLeavesTotal = state.countDimensionsGapped
+    dimensionsUnconstrained: DatatypeLeavesTotal = state.dimensionsUnconstrained
+    gapRangeStart: Array1DElephino = state.gapRangeStart
+    gapsWhere: Array1DLeavesTotal = state.gapsWhere
+    leafAbove: Array1DLeavesTotal = state.leafAbove
+    leafBelow: Array1DLeavesTotal = state.leafBelow
+    foldGroups: Array1DFoldsTotal = state.foldGroups
+    foldsTotal: DatatypeFoldsTotal = state.foldsTotal
+    gap1ndex: DatatypeLeavesTotal = state.gap1ndex
+    gap1ndexCeiling: DatatypeElephino = state.gap1ndexCeiling
+    groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
+    indexDimension: DatatypeLeavesTotal = state.indexDimension
+    indexLeaf: DatatypeLeavesTotal = state.indexLeaf
+    indexMiniGap: DatatypeElephino = state.indexMiniGap
+    leaf1ndex: DatatypeElephino = state.leaf1ndex
+    leafConnectee: DatatypeElephino = state.leafConnectee
+    taskIndex: DatatypeLeavesTotal = state.taskIndex
+    mapShape, leavesTotal, taskDivisions, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, foldsTotal, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, taskIndex = doTheNeedful(mapShape, leavesTotal, taskDivisions, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, foldsTotal, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, taskIndex)
+    return ComputationState(mapShape=mapShape, leavesTotal=leavesTotal, taskDivisions=taskDivisions, countDimensionsGapped=countDimensionsGapped, dimensionsUnconstrained=dimensionsUnconstrained, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, foldGroups=foldGroups, foldsTotal=foldsTotal, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, groupsOfFolds=groupsOfFolds, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, taskIndex=taskIndex)

mapFolding/syntheticModules/numbaCount.py

@@ -0,0 +1,90 @@
+from  import , , 
+from mapFolding.theSSOT import ComputationState, ComputationState, ComputationState
+import copy
+
+@(ComputationState(ComputationState), _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(statePARALLEL: ComputationState) -> ComputationState:
+    stateComplete = copy.deepcopy(statePARALLEL)
+    for indexSherpa in range(statePARALLEL.taskDivisions):
+        state = copy.deepcopy(statePARALLEL)
+        state.taskIndex = indexSherpa
+        while state.leaf1ndex > 0:
+            if state.leaf1ndex <= 1 or state.leafBelow[0] == 1:
+                if state.leaf1ndex > state.leavesTotal:
+                    state.groupsOfFolds += 1
+                else:
+                    state = state
+                    while state.indexDimension < state.dimensionsTotal:
+                        if state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex] == state.leaf1ndex:
+                            state = state
+                        else:
+                            state = state
+                            while state.leafConnectee != state.leaf1ndex:
+                                if state.leaf1ndex != state.taskDivisions or state.leafConnectee % state.taskDivisions == state.taskIndex:
+                                    state = state
+                                state = state
+                        state = state
+                    state = state
+                    while state.indexMiniGap < state.gap1ndexCeiling:
+                        state = state
+                        state = state
+            while state.leaf1ndex > 0 and state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1]:
+                state = state
+            if state.leaf1ndex > 0:
+                state = state
+        stateComplete.foldGroups[state.taskIndex] = state.groupsOfFolds
+    return stateComplete
+
+@(ComputationState(ComputationState), _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(state: ComputationState) -> ComputationState:
+    while state.leaf1ndex > 0:
+        if state.leaf1ndex <= 1 or state.leafBelow[0] == 1:
+            if state.leaf1ndex > state.leavesTotal:
+                state.groupsOfFolds += 1
+            else:
+                state = state
+                while state.indexDimension < state.dimensionsTotal:
+                    state = state
+                    if state.leafConnectee == state.leaf1ndex:
+                        state = state
+                    else:
+                        while state.leafConnectee != state.leaf1ndex:
+                            state = state
+                            state = state
+                    state = state
+                state = state
+                while state.indexMiniGap < state.gap1ndexCeiling:
+                    state = state
+                    state = state
+        while state.leaf1ndex > 0 and state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1]:
+            state = state
+        if state.leaf1ndex > 0:
+            state = state
+    state.foldGroups[state.taskIndex] = state.groupsOfFolds
+    return state
+
+@(ComputationState(ComputationState), _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(state: ComputationState) -> ComputationState:
+    while state.leaf1ndex > 0:
+        if state.leaf1ndex <= 1 or state.leafBelow[0] == 1:
+            state = state
+            while state.indexDimension < state.dimensionsTotal:
+                state = state
+                if state.leafConnectee == state.leaf1ndex:
+                    state = state
+                else:
+                    while state.leafConnectee != state.leaf1ndex:
+                        state = state
+                        state = state
+                state = state
+            if not state.dimensionsUnconstrained:
+                state = state
+            state = state
+            while state.indexMiniGap < state.gap1ndexCeiling:
+                state = state
+                state = state
+        if state.leaf1ndex > 0:
+            state = state
+        if state.gap1ndex > 0:
+            break
+    return state

mapFolding/syntheticModules/numbaCountExample.py

@@ -0,0 +1,158 @@
+from mapFolding.theSSOT import indexMy, indexTrack
+from numba import uint16, prange, int64, jit
+from numpy import ndarray, dtype, integer
+from typing import Any
+
+@jit((uint16[:, :, ::1], uint16[::1], uint16[::1], uint16[:, ::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] > 0:
+        if my[indexMy.leaf1ndex] <= 1 or track[indexTrack.leafBelow, 0] == 1:
+            my[indexMy.dimensionsUnconstrained] = my[indexMy.dimensionsTotal]
+            my[indexMy.gap1ndexCeiling] = track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex] - 1]
+            my[indexMy.indexDimension] = 0
+            while my[indexMy.indexDimension] < my[indexMy.dimensionsTotal]:
+                if connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]] == my[indexMy.leaf1ndex]:
+                    my[indexMy.dimensionsUnconstrained] -= 1
+                else:
+                    my[indexMy.leafConnectee] = connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]]
+                    while my[indexMy.leafConnectee] != my[indexMy.leaf1ndex]:
+                        gapsWhere[my[indexMy.gap1ndexCeiling]] = my[indexMy.leafConnectee]
+                        if track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] == 0:
+                            my[indexMy.gap1ndexCeiling] += 1
+                        track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] += 1
+                        my[indexMy.leafConnectee] = connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], track[indexTrack.leafBelow, my[indexMy.leafConnectee]]]
+                my[indexMy.indexDimension] += 1
+            if not my[indexMy.dimensionsUnconstrained]:
+                my[indexMy.indexLeaf] = 0
+                while my[indexMy.indexLeaf] < my[indexMy.leaf1ndex]:
+                    gapsWhere[my[indexMy.gap1ndexCeiling]] = my[indexMy.indexLeaf]
+                    my[indexMy.gap1ndexCeiling] += 1
+                    my[indexMy.indexLeaf] += 1
+            my[indexMy.indexMiniGap] = my[indexMy.gap1ndex]
+            while my[indexMy.indexMiniGap] < my[indexMy.gap1ndexCeiling]:
+                gapsWhere[my[indexMy.gap1ndex]] = gapsWhere[my[indexMy.indexMiniGap]]
+                if track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] == my[indexMy.dimensionsUnconstrained]:
+                    my[indexMy.gap1ndex] += 1
+                track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] = 0
+                my[indexMy.indexMiniGap] += 1
+        if my[indexMy.leaf1ndex] > 0:
+            my[indexMy.gap1ndex] -= 1
+            track[indexTrack.leafAbove, my[indexMy.leaf1ndex]] = gapsWhere[my[indexMy.gap1ndex]]
+            track[indexTrack.leafBelow, my[indexMy.leaf1ndex]] = track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]]
+            track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]] = my[indexMy.leaf1ndex]
+            track[indexTrack.leafAbove, track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]] = my[indexMy.leaf1ndex]
+            track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex]] = my[indexMy.gap1ndex]
+            my[indexMy.leaf1ndex] += 1
+        if my[indexMy.gap1ndex] > 0:
+            return
+
+@jit((uint16[:, :, ::1], int64[::1], uint16[::1], uint16[::1], uint16[:, ::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]
+    for indexSherpa in prange(taskDivisionsPrange):
+        groupsOfFolds: int = 0
+        gapsWhere = gapsWherePARALLEL.copy()
+        my = myPARALLEL.copy()
+        track = trackPARALLEL.copy()
+        my[indexMy.taskIndex] = indexSherpa
+        while my[indexMy.leaf1ndex] > 0:
+            if my[indexMy.leaf1ndex] <= 1 or track[indexTrack.leafBelow, 0] == 1:
+                if my[indexMy.leaf1ndex] > foldGroups[-1]:
+                    groupsOfFolds += 1
+                else:
+                    my[indexMy.dimensionsUnconstrained] = my[indexMy.dimensionsTotal]
+                    my[indexMy.gap1ndexCeiling] = track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex] - 1]
+                    my[indexMy.indexDimension] = 0
+                    while my[indexMy.indexDimension] < my[indexMy.dimensionsTotal]:
+                        if connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]] == my[indexMy.leaf1ndex]:
+                            my[indexMy.dimensionsUnconstrained] -= 1
+                        else:
+                            my[indexMy.leafConnectee] = connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]]
+                            while my[indexMy.leafConnectee] != my[indexMy.leaf1ndex]:
+                                if my[indexMy.leaf1ndex] != my[indexMy.taskDivisions] or my[indexMy.leafConnectee] % my[indexMy.taskDivisions] == my[indexMy.taskIndex]:
+                                    gapsWhere[my[indexMy.gap1ndexCeiling]] = my[indexMy.leafConnectee]
+                                    if track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] == 0:
+                                        my[indexMy.gap1ndexCeiling] += 1
+                                    track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] += 1
+                                my[indexMy.leafConnectee] = connectionGraph[my[indexMy.indexDimension], my[indexMy.leaf1ndex], track[indexTrack.leafBelow, my[indexMy.leafConnectee]]]
+                        my[indexMy.indexDimension] += 1
+                    my[indexMy.indexMiniGap] = my[indexMy.gap1ndex]
+                    while my[indexMy.indexMiniGap] < my[indexMy.gap1ndexCeiling]:
+                        gapsWhere[my[indexMy.gap1ndex]] = gapsWhere[my[indexMy.indexMiniGap]]
+                        if track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] == my[indexMy.dimensionsUnconstrained]:
+                            my[indexMy.gap1ndex] += 1
+                        track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] = 0
+                        my[indexMy.indexMiniGap] += 1
+            while my[indexMy.leaf1ndex] > 0 and my[indexMy.gap1ndex] == track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex] - 1]:
+                my[indexMy.leaf1ndex] -= 1
+                track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]] = track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]
+                track[indexTrack.leafAbove, track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]] = track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]
+            if my[indexMy.leaf1ndex] > 0:
+                my[indexMy.gap1ndex] -= 1
+                track[indexTrack.leafAbove, my[indexMy.leaf1ndex]] = gapsWhere[my[indexMy.gap1ndex]]
+                track[indexTrack.leafBelow, my[indexMy.leaf1ndex]] = track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]]
+                track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]] = my[indexMy.leaf1ndex]
+                track[indexTrack.leafAbove, track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]] = my[indexMy.leaf1ndex]
+                track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex]] = my[indexMy.gap1ndex]
+                my[indexMy.leaf1ndex] += 1
+        foldGroups[my[indexMy.taskIndex]] = groupsOfFolds
+
+@jit((uint16[:, :, ::1], int64[::1], uint16[::1], uint16[::1], uint16[:, ::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]
+    leafAbove = track[indexTrack.leafAbove.value]
+    leaf1ndex = my[indexMy.leaf1ndex.value]
+    dimensionsUnconstrained = my[indexMy.dimensionsUnconstrained.value]
+    dimensionsTotal = my[indexMy.dimensionsTotal.value]
+    gap1ndexCeiling = my[indexMy.gap1ndexCeiling.value]
+    indexDimension = my[indexMy.indexDimension.value]
+    leafConnectee = my[indexMy.leafConnectee.value]
+    indexMiniGap = my[indexMy.indexMiniGap.value]
+    gap1ndex = my[indexMy.gap1ndex.value]
+    taskIndex = my[indexMy.taskIndex.value]
+    groupsOfFolds: int = 0
+    while leaf1ndex > 0:
+        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:
+                    leafConnectee = connectionGraph[indexDimension, leaf1ndex, leaf1ndex]
+                    if leafConnectee == leaf1ndex:
+                        dimensionsUnconstrained -= 1
+                    else:
+                        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 > 0 and gap1ndex == gapRangeStart[leaf1ndex - 1]:
+            leaf1ndex -= 1
+            leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]
+            leafAbove[leafBelow[leaf1ndex]] = leafAbove[leaf1ndex]
+        if leaf1ndex > 0:
+            gap1ndex -= 1
+            leafAbove[leaf1ndex] = gapsWhere[gap1ndex]
+            leafBelow[leaf1ndex] = leafBelow[leafAbove[leaf1ndex]]
+            leafBelow[leafAbove[leaf1ndex]] = leaf1ndex
+            leafAbove[leafBelow[leaf1ndex]] = leaf1ndex
+            gapRangeStart[leaf1ndex] = gap1ndex
+            leaf1ndex += 1
+    foldGroups[taskIndex] = groupsOfFolds