mapFolding 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

mapFolding/someAssemblyRequired/synthesizeNumbaModules.py

@@ -4,42 +4,76 @@ everything I am doing. I would rather benefit from humanity's
 collective wisdom."""
 from mapFolding.someAssemblyRequired.synthesizeNumba import *
 
-def makeFlowNumbaOptimized(listCallablesInline: List[str], callableDispatcher: Optional[bool] = False, algorithmSource: Optional[ModuleType] = None, relativePathWrite: Optional[pathlib.Path] = None, formatFilenameWrite: Optional[str] = None) -> List[youOughtaKnow]:
-	if relativePathWrite and relativePathWrite.is_absolute():
-		raise ValueError("The path to write the module must be relative to the root of the package.")
-	if not algorithmSource:
-		algorithmSource = getAlgorithmSource()
+def getFunctionDef(algorithmSource: ModuleType, *arguments, **keywordArguments) -> tuple[ast.FunctionDef, UniversalImportTracker]:
+	pythonSource = inspect.getsource(algorithmSource)
+	astModule: ast.Module = ast.parse(pythonSource, type_comments=True)
+	FunctionDefTarget, allImports = makeFunctionDef(astModule, *arguments, **keywordArguments)
+	return FunctionDefTarget, allImports
+
+def makePythonSource(listFunctionDefs: list[ast.FunctionDef], listAstImports: list[ast.Import | ast.ImportFrom], additional_imports: list[str]) -> str:
+	astModule = ast.Module(body=cast(list[ast.stmt], listAstImports + listFunctionDefs), type_ignores=[])
+	ast.fix_missing_locations(astModule)
+	pythonSource = ast.unparse(astModule)
+	if not pythonSource: raise FREAKOUT
+	pythonSource = autoflake.fix_code(pythonSource, additional_imports)
+	return pythonSource
 
-	listStuffYouOughtaKnow: List[youOughtaKnow] = []
+def writePythonAsModule(pythonSource: str, listCallableSynthesized: list[str], relativePathWrite: Path | None, filenameWrite: str | None, formatFilenameWrite: str | None) -> list[youOughtaKnow]:
+	pathFilename = None
+	if not relativePathWrite:
+		pathWrite = getPathSyntheticModules()
+	else:
+		pathWrite = getPathPackage() / relativePathWrite
 
-	def doThisStuff(callableTarget: str, parametersNumba: Optional[ParametersNumba], inlineCallables: bool, unpackArrays: bool, allImports: Optional[UniversalImportTracker], relativePathWrite: Optional[pathlib.Path], formatFilenameWrite: Optional[str]) -> youOughtaKnow:
-		pythonSource = inspect.getsource(algorithmSource)
-		pythonSource = makeAstModuleForOneCallable(pythonSource, callableTarget, parametersNumba, inlineCallables, unpackArrays, allImports)
-		if not pythonSource: raise FREAKOUT
-		pythonSource = autoflake.fix_code(pythonSource, ['mapFolding', 'numba', 'numpy'])
+	if not formatFilenameWrite:
+		formatFilenameWrite = formatFilenameModuleDEFAULT
 
-		if not relativePathWrite:
-			pathWrite = getPathSyntheticModules()
+	if not filenameWrite:
+		if len(listCallableSynthesized) == 1:
+			callableTarget = listCallableSynthesized[0]
 		else:
-			pathWrite = getPathPackage() / relativePathWrite
-		if not formatFilenameWrite:
-			formatFilenameWrite = formatModuleNameDEFAULT + '.py'
-		pathFilename = pathWrite  / formatFilenameWrite.format(callableTarget=callableTarget)
+			callableTarget = 'count'
+		filenameWrite = formatFilenameWrite.format(callableTarget=callableTarget)
+	else:
+		if not filenameWrite.endswith('.py'):
+			warnings.warn(f"Filename {filenameWrite=} does not end with '.py'.")
 
-		pathFilename.write_text(pythonSource)
+	pathFilename = pathWrite / filenameWrite
 
-		howIsThisStillAThing = getPathPackage().parent
-		dumbassPythonNamespace = pathFilename.relative_to(howIsThisStillAThing).with_suffix('').parts
-		ImaModule = '.'.join(dumbassPythonNamespace)
+	pathFilename.write_text(pythonSource)
+
+	howIsThisStillAThing = getPathPackage().parent
+	dumbassPythonNamespace = pathFilename.relative_to(howIsThisStillAThing).with_suffix('').parts
+	ImaModule = '.'.join(dumbassPythonNamespace)
+
+	listStuffYouOughtaKnow: list[youOughtaKnow] = []
+
+	for callableTarget in listCallableSynthesized:
 		astImportFrom = ast.ImportFrom(module=ImaModule, names=[ast.alias(name=callableTarget, asname=None)], level=0)
+		stuff = youOughtaKnow(callableSynthesized=callableTarget, pathFilenameForMe=pathFilename, astForCompetentProgrammers=astImportFrom)
+		listStuffYouOughtaKnow.append(stuff)
+
+	return listStuffYouOughtaKnow
 
-		return youOughtaKnow(callableSynthesized=callableTarget, pathFilenameForMe=pathFilename, astForCompetentProgrammers=astImportFrom)
+def makeFlowNumbaOptimized(listCallablesInline: list[str], callableDispatcher: bool | None = False, algorithmSource: ModuleType | None = None, relativePathWrite: Path | None = None, filenameModuleWrite: str | None = None, formatFilenameWrite: str | None = None) -> list[youOughtaKnow]:
+	if relativePathWrite and relativePathWrite.is_absolute():
+		raise ValueError("The path to write the module must be relative to the root of the package.")
+	if not algorithmSource:
+		algorithmSource = getAlgorithmSource()
+
+	Z0Z_filenameModuleWrite = 'numbaCount.py'
 
+	listStuffYouOughtaKnow: list[youOughtaKnow] = []
+	additional_imports = ['mapFolding', 'numba', 'numpy']
+
+	listFunctionDefs: list[ast.FunctionDef] = []
+	allImportsModule = UniversalImportTracker()
 	for callableTarget in listCallablesInline:
 		parametersNumba = None
 		inlineCallables = True
 		unpackArrays 	= False
 		allImports 		= None
+		filenameWrite 	= None
 		match callableTarget:
 			case 'countParallel':
 				parametersNumba = parametersNumbaSuperJitParallel
@@ -48,7 +82,17 @@ def makeFlowNumbaOptimized(listCallablesInline: List[str], callableDispatcher: O
 				unpackArrays = True
 			case 'countInitialize':
 				parametersNumba = parametersNumbaDEFAULT
-		listStuffYouOughtaKnow.append(doThisStuff(callableTarget, parametersNumba, inlineCallables, unpackArrays, allImports, relativePathWrite, formatFilenameWrite))
+		FunctionDefTarget, allImports = getFunctionDef(algorithmSource, callableTarget, parametersNumba, inlineCallables, unpackArrays, allImports)
+		listFunctionDefs.append(FunctionDefTarget)
+		allImportsModule.update(allImports)
+
+	listAstImports = allImportsModule.makeListAst()
+	pythonSource = makePythonSource(listFunctionDefs, listAstImports, additional_imports)
+
+	filenameWrite = filenameModuleWrite or Z0Z_filenameModuleWrite
+
+	listStuff = writePythonAsModule(pythonSource, listCallablesInline, relativePathWrite, filenameWrite, formatFilenameWrite)
+	listStuffYouOughtaKnow.extend(listStuff)
 
 	if callableDispatcher:
 		callableTarget 	= getAlgorithmDispatcher().__name__
@@ -56,22 +100,24 @@ def makeFlowNumbaOptimized(listCallablesInline: List[str], callableDispatcher: O
 		inlineCallables	= False
 		unpackArrays	= False
 		allImports 		= UniversalImportTracker()
+		filenameWrite 	= None
 		for stuff in listStuffYouOughtaKnow:
 			statement = stuff.astForCompetentProgrammers
 			if isinstance(statement, (ast.Import, ast.ImportFrom)):
 				allImports.addAst(statement)
+		FunctionDefTarget, allImports = getFunctionDef(algorithmSource, callableTarget, parametersNumba, inlineCallables, unpackArrays, allImports)
+		listAstImports = allImports.makeListAst()
+
+		pythonSource = makePythonSource([FunctionDefTarget], listAstImports, additional_imports)
 
-		listStuffYouOughtaKnow.append(doThisStuff(callableTarget, parametersNumba, inlineCallables, unpackArrays, allImports, relativePathWrite, formatFilenameWrite))
+		listStuff = writePythonAsModule(pythonSource, [callableTarget], relativePathWrite, filenameWrite, formatFilenameWrite)
+		listStuffYouOughtaKnow.extend(listStuff)
 
 	return listStuffYouOughtaKnow
 
 if __name__ == '__main__':
-	setDatatypeModule('numpy', sourGrapes=True)
-	setDatatypeFoldsTotal('int64', sourGrapes=True)
-	setDatatypeElephino('uint8', sourGrapes=True)
-	setDatatypeLeavesTotal('uint8', sourGrapes=True)
-	Z0Z_setDatatypeModuleScalar('numba')
-	Z0Z_setDecoratorCallable('jit')
-	listCallablesInline: List[str] = ['countInitialize', 'countParallel', 'countSequential']
+	# Z0Z_setDatatypeModuleScalar('numba')
+	# Z0Z_setDecoratorCallable('jit')
+	listCallablesInline: list[str] = ['countInitialize', 'countParallel', 'countSequential']
 	callableDispatcher = True
 	makeFlowNumbaOptimized(listCallablesInline, callableDispatcher)

mapFolding/syntheticModules/numbaCount.py

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

mapFolding/syntheticModules/numba_doTheNeedful.py

@@ -1,18 +1,11 @@
-from mapFolding.syntheticModules.numba_countInitialize import countInitialize
-from mapFolding.syntheticModules.numba_countParallel import countParallel
-from mapFolding.syntheticModules.numba_countSequential import countSequential
 from mapFolding import indexMy
-from numba import int64
-from numba import jit
-from numba import uint8
-from numpy import dtype
-from numpy import ndarray
-from numpy import integer
-from typing import Tuple
+from mapFolding.syntheticModules.numbaCount import countInitialize, countParallel, countSequential
+from numba import uint16, jit, int64
+from numpy import ndarray, dtype, integer
 from typing import Any
 
-@jit((uint8[:, :, ::1], int64[::1], 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 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:
+@jit((uint16[:, :, ::1], int64[::1], 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 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:
     countInitialize(connectionGraph, gapsWhere, my, track)
     if my[indexMy.taskDivisions.value] > 0:
         countParallel(connectionGraph, foldGroups, gapsWhere, my, track)