mapFolding 0.11.1__py3-none-any.whl → 0.11.3__py3-none-any.whl

mapFolding/someAssemblyRequired/synthesizeNumbaJob.py

@@ -1,314 +0,0 @@
-"""
-Job-specific Numba Code Generation for Map Folding Calculations
-
-This module specializes in generating highly-optimized, single-purpose Numba modules
-for specific map folding calculation jobs. Unlike the general-purpose transformation
-in toolboxNumba.py, this module creates standalone Python modules optimized for a
-single map shape with statically-encoded parameters.
-
-The code generation assembly line focuses on:
-
-1. Converting function parameters to initialized variables with concrete values.
-2. Replacing dynamic computations with statically-known values.
-3. Eliminating unused code paths and variables.
-4. Adding progress tracking for long-running calculations.
-5. Applying appropriate Numba optimizations for the specific calculation.
-
-This creates extremely fast, specialized implementations that can be run directly
-as Python scripts or further compiled into standalone executables.
-"""
-
-from mapFolding import getPathFilenameFoldsTotal, raiseIfNoneGitHubIssueNumber3, The
-from mapFolding.someAssemblyRequired import (
-	ast_Identifier,
-	Be,
-	extractFunctionDef,
-	IfThis,
-	IngredientsFunction,
-	IngredientsModule,
-	LedgerOfImports,
-	Make,
-	NodeChanger,
-	NodeTourist,
-	str_nameDOTname,
-	Then,
-	write_astModule,
-)
-from mapFolding.someAssemblyRequired.RecipeJob import RecipeJob
-from mapFolding.someAssemblyRequired.toolboxNumba import parametersNumbaLight, SpicesJobNumba, decorateCallableWithNumba
-from mapFolding.someAssemblyRequired.transformationTools import dictionaryEstimates, makeInitializedComputationState
-from pathlib import PurePosixPath
-from typing import cast, NamedTuple
-from Z0Z_tools import autoDecodingRLE
-import ast
-"""Synthesize one file to compute `foldsTotal` of `mapShape`."""
-
-list_IdentifiersNotUsedAllHARDCODED = ['concurrencyLimit', 'foldsTotal', 'mapShape',]
-list_IdentifiersNotUsedParallelSequentialHARDCODED = ['indexLeaf']
-list_IdentifiersNotUsedSequentialHARDCODED = ['foldGroups', 'taskDivisions', 'taskIndex',]
-
-list_IdentifiersReplacedHARDCODED = ['groupsOfFolds',]
-
-list_IdentifiersStaticValuesHARDCODED = ['dimensionsTotal', 'leavesTotal',]
-
-list_IdentifiersNotUsedHARDCODED = list_IdentifiersStaticValuesHARDCODED + list_IdentifiersReplacedHARDCODED + list_IdentifiersNotUsedAllHARDCODED + list_IdentifiersNotUsedParallelSequentialHARDCODED + list_IdentifiersNotUsedSequentialHARDCODED
-
-def addLauncherNumbaProgress(ingredientsModule: IngredientsModule, ingredientsFunction: IngredientsFunction, job: RecipeJob, spices: SpicesJobNumba) -> tuple[IngredientsModule, IngredientsFunction]:
-	"""
-	Add progress tracking capabilities to a Numba-optimized function.
-
-	This function modifies both the module and the function to integrate Numba-compatible
-	progress tracking for long-running calculations. It performs several key transformations:
-
-	1. Adds a progress bar parameter to the function signature
-	2. Replaces counting increments with progress bar updates
-	3. Creates a launcher section that displays and updates progress
-	4. Configures file output to save results upon completion
-
-	The progress tracking is particularly important for map folding calculations
-	which can take hours or days to complete, providing visual feedback and
-	estimated completion times.
-
-	Parameters:
-		ingredientsModule: The module where the function is defined.
-		ingredientsFunction: The function to modify with progress tracking.
-		job: Configuration specifying shape details and output paths.
-		spices: Configuration specifying progress bar details.
-
-	Returns:
-		A tuple containing the modified module and function with progress tracking.
-	"""
-	linesLaunch: str = f"""
-if __name__ == '__main__':
-	with ProgressBar(total={job.foldsTotalEstimated}, update_interval=2) as statusUpdate:
-		{job.countCallable}(statusUpdate)
-		foldsTotal = statusUpdate.n * {job.state.leavesTotal}
-		print('\\nmap {job.state.mapShape} =', foldsTotal)
-		writeStream = open('{job.pathFilenameFoldsTotal.as_posix()}', 'w')
-		writeStream.write(str(foldsTotal))
-		writeStream.close()
-"""
-	numba_progressPythonClass: ast_Identifier = 'ProgressBar'
-	numba_progressNumbaType: ast_Identifier = 'ProgressBarType'
-	ingredientsModule.imports.addImportFrom_asStr('numba_progress', numba_progressPythonClass)
-	ingredientsModule.imports.addImportFrom_asStr('numba_progress', numba_progressNumbaType)
-
-	ast_argNumbaProgress = ast.arg(arg=spices.numbaProgressBarIdentifier, annotation=ast.Name(id=numba_progressPythonClass, ctx=ast.Load()))
-	ingredientsFunction.astFunctionDef.args.args.append(ast_argNumbaProgress)
-
-	findThis = IfThis.isAugAssignAndTargetIs(IfThis.isName_Identifier(job.shatteredDataclass.countingVariableName.id))
-	doThat = Then.replaceWith(Make.Expr(Make.Call(Make.Attribute(Make.Name(spices.numbaProgressBarIdentifier),'update'),[Make.Constant(1)])))
-	countWithProgressBar = NodeChanger(findThis, doThat)
-	countWithProgressBar.visit(ingredientsFunction.astFunctionDef)
-
-	removeReturnStatement = NodeChanger(Be.Return, Then.removeIt)
-	removeReturnStatement.visit(ingredientsFunction.astFunctionDef)
-	ingredientsFunction.astFunctionDef.returns = Make.Constant(value=None)
-
-	ingredientsModule.appendLauncher(ast.parse(linesLaunch))
-
-	return ingredientsModule, ingredientsFunction
-
-def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: IngredientsFunction, job: RecipeJob) -> IngredientsFunction:
-	"""
-	Convert function parameters into initialized variables with concrete values.
-
-	This function implements a critical transformation that converts function parameters
-	into statically initialized variables in the function body. This enables several
-	optimizations:
-
-	1. Eliminating parameter passing overhead.
-	2. Embedding concrete values directly in the code.
-	3. Allowing Numba to optimize based on known value characteristics.
-	4. Simplifying function signatures for specialized use cases.
-
-	The function handles different data types (scalars, arrays, custom types) appropriately,
-	replacing abstract parameter references with concrete values from the computation state.
-	It also removes unused parameters and variables to eliminate dead code.
-
-	Parameters:
-		ingredientsFunction: The function to transform.
-		job: Recipe containing concrete values for parameters and field metadata.
-
-	Returns:
-		The modified function with parameters converted to initialized variables.
-	"""
-	ingredientsFunction.imports.update(job.shatteredDataclass.imports)
-
-	list_argCuzMyBrainRefusesToThink = ingredientsFunction.astFunctionDef.args.args + ingredientsFunction.astFunctionDef.args.posonlyargs + ingredientsFunction.astFunctionDef.args.kwonlyargs
-	list_arg_arg: list[ast_Identifier] = [ast_arg.arg for ast_arg in list_argCuzMyBrainRefusesToThink]
-	listName: list[ast.Name] = []
-	NodeTourist(Be.Name, Then.appendTo(listName)).visit(ingredientsFunction.astFunctionDef)
-	list_Identifiers: list[ast_Identifier] = [astName.id for astName in listName]
-	list_IdentifiersNotUsed: list[ast_Identifier] = list(set(list_arg_arg) - set(list_Identifiers))
-
-	for ast_arg in list_argCuzMyBrainRefusesToThink:
-		if ast_arg.arg in job.shatteredDataclass.field2AnnAssign:
-			if ast_arg.arg in list_IdentifiersNotUsed:
-				pass
-			else:
-				ImaAnnAssign, elementConstructor = job.shatteredDataclass.Z0Z_field2AnnAssign[ast_arg.arg]
-				match elementConstructor:
-					case 'scalar':
-						cast(ast.Constant, cast(ast.Call, ImaAnnAssign.value).args[0]).value = int(job.state.__dict__[ast_arg.arg])
-					case 'array':
-						dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[ast_arg.arg], True)
-						dataAs_astExpr: ast.expr = cast(ast.Expr, ast.parse(dataAsStrRLE).body[0]).value
-						cast(ast.Call, ImaAnnAssign.value).args = [dataAs_astExpr]
-					case _:
-						list_exprDOTannotation: list[ast.expr] = []
-						list_exprDOTvalue: list[ast.expr] = []
-						for dimension in job.state.mapShape:
-							list_exprDOTannotation.append(Make.Name(elementConstructor))
-							list_exprDOTvalue.append(Make.Call(Make.Name(elementConstructor), [Make.Constant(dimension)]))
-						cast(ast.Tuple, cast(ast.Subscript, cast(ast.AnnAssign, ImaAnnAssign).annotation).slice).elts = list_exprDOTannotation
-						cast(ast.Tuple, ImaAnnAssign.value).elts = list_exprDOTvalue
-
-				ingredientsFunction.astFunctionDef.body.insert(0, ImaAnnAssign)
-
-			findThis = IfThis.is_arg_Identifier(ast_arg.arg)
-			remove_arg = NodeChanger(findThis, Then.removeIt)
-			remove_arg.visit(ingredientsFunction.astFunctionDef)
-
-	ast.fix_missing_locations(ingredientsFunction.astFunctionDef)
-	return ingredientsFunction
-
-def makeJobNumba(job: RecipeJob, spices: SpicesJobNumba) -> None:
-	"""
-	Generate a highly-optimized, single-purpose Numba module for a specific map shape.
-
-	This function implements the complete transformation assembly line for creating a
-	standalone, specialized implementation for calculating map folding solutions for
-	a specific shape. The process includes:
-
-	1. Extracting the counting function from the source module
-	2. Removing unused code paths based on static analysis
-	3. Replacing dynamic variables with concrete values
-	4. Converting parameters to initialized variables
-	5. Adding progress tracking if requested
-	6. Applying Numba optimizations and type specifications
-	7. Writing the final module to the filesystem
-
-	The resulting Python module is both human-readable and extraordinarily efficient,
-	with all shape-specific optimizations statically encoded. This creates specialized
-	implementations that can be orders of magnitude faster than general-purpose code.
-
-	Parameters:
-		job: Configuration specifying the target shape, paths, and computation state.
-		spices: Configuration specifying Numba and progress tracking options.
-	"""
-	astFunctionDef = extractFunctionDef(job.source_astModule, job.countCallable)
-	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
-	ingredientsCount: IngredientsFunction = IngredientsFunction(astFunctionDef, LedgerOfImports())
-
-	# Remove `foldGroups` and any other unused statements, so you can dynamically determine which variables are not used
-	findThis = IfThis.isAssignAndTargets0Is(IfThis.isSubscript_Identifier('foldGroups'))
-	doThat = Then.removeIt
-	remove_foldGroups = NodeChanger(findThis, doThat)
-	remove_foldGroups.visit(ingredientsCount.astFunctionDef)
-
-	# replace identifiers with static values with their values, so you can dynamically determine which variables are not used
-	list_IdentifiersStaticValues = list_IdentifiersStaticValuesHARDCODED
-	for identifier in list_IdentifiersStaticValues:
-		findThis = IfThis.isName_Identifier(identifier)
-		doThat = Then.replaceWith(Make.Constant(int(job.state.__dict__[identifier])))
-		NodeChanger(findThis, doThat).visit(ingredientsCount.astFunctionDef)
-
-	ingredientsModule = IngredientsModule()
-	# This launcher eliminates the use of one identifier, so run it now and you can dynamically determine which variables are not used
-	if spices.useNumbaProgressBar:
-		ingredientsModule, ingredientsCount = addLauncherNumbaProgress(ingredientsModule, ingredientsCount, job, spices)
-		spices.parametersNumba['nogil'] = True
-	else:
-		linesLaunch: str = f"""
-if __name__ == '__main__':
-	import time
-	timeStart = time.perf_counter()
-	foldsTotal = {job.countCallable}() * {job.state.leavesTotal}
-	print(time.perf_counter() - timeStart)
-	print('\\nmap {job.state.mapShape} =', foldsTotal)
-	writeStream = open('{job.pathFilenameFoldsTotal.as_posix()}', 'w')
-	writeStream.write(str(foldsTotal))
-	writeStream.close()
-"""
-	# from mapFolding.oeis import getFoldsTotalKnown
-	# print(foldsTotal == getFoldsTotalKnown({job.state.mapShape}))
-		ingredientsModule.appendLauncher(ast.parse(linesLaunch))
-		changeReturnParallelCallable = NodeChanger(Be.Return, Then.replaceWith(Make.Return(job.shatteredDataclass.countingVariableName)))
-		changeReturnParallelCallable.visit(ingredientsCount.astFunctionDef)
-		ingredientsCount.astFunctionDef.returns = job.shatteredDataclass.countingVariableAnnotation
-
-	ingredientsCount = move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsCount, job)
-
-	class DatatypeConfig(NamedTuple):
-		Z0Z_module: str_nameDOTname
-		fml: ast_Identifier
-		Z0Z_type_name: ast_Identifier
-		Z0Z_asname: ast_Identifier | None = None
-
-	listDatatypeConfigs = [
-		DatatypeConfig(fml='DatatypeLeavesTotal', Z0Z_module='numba', Z0Z_type_name='uint8'),
-		DatatypeConfig(fml='DatatypeElephino', Z0Z_module='numba', Z0Z_type_name='uint16'),
-		DatatypeConfig(fml='DatatypeFoldsTotal', Z0Z_module='numba', Z0Z_type_name='uint64'),
-	]
-
-	for datatypeConfig in listDatatypeConfigs:
-		ingredientsModule.imports.addImportFrom_asStr(datatypeConfig.Z0Z_module, datatypeConfig.Z0Z_type_name)
-		statement = Make.Assign(
-			[Make.Name(datatypeConfig.fml, ast.Store())],
-			Make.Name(datatypeConfig.Z0Z_type_name)
-		)
-		ingredientsModule.appendPrologue(statement=statement)
-
-	ingredientsCount.imports.removeImportFromModule('mapFolding.theSSOT')
-
-	listNumPyTypeConfigs = [
-		DatatypeConfig(fml='Array1DLeavesTotal', Z0Z_module='numpy', Z0Z_type_name='uint8', Z0Z_asname='Array1DLeavesTotal'),
-		DatatypeConfig(fml='Array1DElephino', Z0Z_module='numpy', Z0Z_type_name='uint16', Z0Z_asname='Array1DElephino'),
-		DatatypeConfig(fml='Array3D', Z0Z_module='numpy', Z0Z_type_name='uint8', Z0Z_asname='Array3D'),
-	]
-
-	for typeConfig in listNumPyTypeConfigs:
-		ingredientsCount.imports.removeImportFrom(typeConfig.Z0Z_module, None, typeConfig.fml)
-		ingredientsCount.imports.addImportFrom_asStr(typeConfig.Z0Z_module, typeConfig.Z0Z_type_name, typeConfig.Z0Z_asname)
-
-	ingredientsCount.astFunctionDef.decorator_list = [] # TODO low-priority, handle this more elegantly
-	# TODO when I add the function signature in numba style back to the decorator, the logic needs to handle `ProgressBarType:`
-	ingredientsCount = decorateCallableWithNumba(ingredientsCount, spices.parametersNumba)
-
-	ingredientsModule.appendIngredientsFunction(ingredientsCount)
-	write_astModule(ingredientsModule, job.pathFilenameModule, job.packageIdentifier)
-
-	"""
-	Overview
-	- the code starts life in theDao.py, which has many optimizations;
-		- `makeNumbaOptimizedFlow` increase optimization especially by using numba;
-		- `makeJobNumba` increases optimization especially by limiting its capabilities to just one set of parameters
-	- the synthesized module must run well as a standalone interpreted-Python script
-	- the next major optimization step will (probably) be to use the module synthesized by `makeJobNumba` to compile a standalone executable
-	- Nevertheless, at each major optimization step, the code is constantly being improved and optimized, so everything must be well organized (read: semantic) and able to handle a range of arbitrary upstream and not disrupt downstream transformations
-
-	Necessary
-	- Move the function's parameters to the function body,
-	- initialize identifiers with their state types and values,
-
-	Optimizations
-	- replace static-valued identifiers with their values
-	- narrowly focused imports
-
-	Minutia
-	- do not use `with` statement inside numba jitted code, except to use numba's obj mode
-	"""
-
-if __name__ == '__main__':
-	mapShape = (1,46)
-	state = makeInitializedComputationState(mapShape)
-	# foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal
-	# foldsTotalEstimated = dictionaryEstimates[state.mapShape] // state.leavesTotal
-	foldsTotalEstimated = 0
-	pathModule = PurePosixPath(The.pathPackage, 'jobs')
-	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
-	aJob = RecipeJob(state, foldsTotalEstimated, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
-	spices = SpicesJobNumba(useNumbaProgressBar=False, parametersNumba=parametersNumbaLight)
-	# spices = SpicesJobNumba()
-	makeJobNumba(aJob, spices)

mapFolding/syntheticModules/numbaCount.py

@@ -1,201 +0,0 @@
-from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
-from copy import deepcopy
-from mapFolding.theSSOT import Array1DElephino, Array1DFoldsTotal, Array1DLeavesTotal, Array3D, ComputationState, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
-from numba import jit
-
-def countInitialize(state: ComputationState) -> ComputationState:
-    while state.gap1ndex == 0:
-        if state.leaf1ndex <= 1 or state.leafBelow[0] == 1:
-            state.dimensionsUnconstrained = state.dimensionsTotal
-            state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
-            state.indexDimension = 0
-            while state.indexDimension < state.dimensionsTotal:
-                state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
-                if state.leafConnectee == state.leaf1ndex:
-                    state.dimensionsUnconstrained -= 1
-                else:
-                    while state.leafConnectee != state.leaf1ndex:
-                        state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
-                        if state.countDimensionsGapped[state.leafConnectee] == 0:
-                            state.gap1ndexCeiling += 1
-                        state.countDimensionsGapped[state.leafConnectee] += 1
-                        state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
-                state.indexDimension += 1
-            if not state.dimensionsUnconstrained:
-                state.indexLeaf = 0
-                while state.indexLeaf < state.leaf1ndex:
-                    state.gapsWhere[state.gap1ndexCeiling] = state.indexLeaf
-                    state.gap1ndexCeiling += 1
-                    state.indexLeaf += 1
-            state.indexMiniGap = state.gap1ndex
-            while state.indexMiniGap < state.gap1ndexCeiling:
-                state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
-                if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
-                    state.gap1ndex += 1
-                state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
-                state.indexMiniGap += 1
-        if state.leaf1ndex > 0:
-            state.gap1ndex -= 1
-            state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
-            state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
-            state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leaf1ndex
-            state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
-            state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
-            state.leaf1ndex += 1
-    return state
-
-@jit(_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 countParallel(leavesTotal: DatatypeLeavesTotal, taskDivisions: DatatypeLeavesTotal, connectionGraph: Array3D, dimensionsTotal: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, foldGroups: Array1DFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, groupsOfFolds: DatatypeFoldsTotal, indexDimension: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, taskIndex: DatatypeLeavesTotal) -> DatatypeFoldsTotal:
-    while leaf1ndex > 0:
-        if leaf1ndex <= 1 or leafBelow[0] == 1:
-            if leaf1ndex > leavesTotal:
-                groupsOfFolds += 1
-            else:
-                dimensionsUnconstrained = dimensionsTotal
-                gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
-                indexDimension = 0
-                while indexDimension < dimensionsTotal:
-                    if connectionGraph[indexDimension, leaf1ndex, leaf1ndex] == leaf1ndex:
-                        dimensionsUnconstrained -= 1
-                    else:
-                        leafConnectee = connectionGraph[indexDimension, leaf1ndex, leaf1ndex]
-                        while leafConnectee != leaf1ndex:
-                            if leaf1ndex != taskDivisions or leafConnectee % taskDivisions == taskIndex:
-                                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
-    return groupsOfFolds
-
-@jit(_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 countSequential(mapShape: tuple[DatatypeLeavesTotal, ...], leavesTotal: DatatypeLeavesTotal, taskDivisions: DatatypeLeavesTotal, concurrencyLimit: DatatypeElephino, connectionGraph: Array3D, dimensionsTotal: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, foldGroups: Array1DFoldsTotal, foldsTotal: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, groupsOfFolds: DatatypeFoldsTotal, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, taskIndex: DatatypeLeavesTotal) -> tuple[tuple[DatatypeLeavesTotal, ...], DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, Array3D, DatatypeLeavesTotal, Array1DLeavesTotal, DatatypeLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array1DFoldsTotal, DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal]:
-    while leaf1ndex > 0:
-        if leaf1ndex <= 1 or leafBelow[0] == 1:
-            if leaf1ndex > leavesTotal:
-                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 == 3 and groupsOfFolds:
-            groupsOfFolds *= 2
-            break
-        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
-    return (mapShape, leavesTotal, taskDivisions, concurrencyLimit, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, foldsTotal, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, taskIndex)
-
-def doTheNeedful(state: ComputationState) -> ComputationState:
-    state = countInitialize(state)
-    if state.taskDivisions > 0:
-        dictionaryConcurrency: dict[int, ConcurrentFuture[ComputationState]] = {}
-        stateParallel = deepcopy(state)
-        with ProcessPoolExecutor(stateParallel.concurrencyLimit) as concurrencyManager:
-            for indexSherpa in range(stateParallel.taskDivisions):
-                state = deepcopy(stateParallel)
-                state.taskIndex = indexSherpa
-                mapShape: tuple[DatatypeLeavesTotal, ...] = state.mapShape
-                leavesTotal: DatatypeLeavesTotal = state.leavesTotal
-                taskDivisions: DatatypeLeavesTotal = state.taskDivisions
-                concurrencyLimit: DatatypeElephino = state.concurrencyLimit
-                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: DatatypeElephino = state.gap1ndex
-                gap1ndexCeiling: DatatypeElephino = state.gap1ndexCeiling
-                groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
-                indexDimension: DatatypeLeavesTotal = state.indexDimension
-                indexLeaf: DatatypeLeavesTotal = state.indexLeaf
-                indexMiniGap: DatatypeElephino = state.indexMiniGap
-                leaf1ndex: DatatypeLeavesTotal = state.leaf1ndex
-                leafConnectee: DatatypeLeavesTotal = state.leafConnectee
-                taskIndex: DatatypeLeavesTotal = state.taskIndex
-                dictionaryConcurrency[indexSherpa] = concurrencyManager.submit(countParallel, leavesTotal, taskDivisions, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexMiniGap, leaf1ndex, leafConnectee, taskIndex)
-            for indexSherpa in range(stateParallel.taskDivisions):
-                stateParallel.foldGroups[indexSherpa] = dictionaryConcurrency[indexSherpa].result()
-        state = stateParallel
-    else:
-        mapShape: tuple[DatatypeLeavesTotal, ...] = state.mapShape
-        leavesTotal: DatatypeLeavesTotal = state.leavesTotal
-        taskDivisions: DatatypeLeavesTotal = state.taskDivisions
-        concurrencyLimit: DatatypeElephino = state.concurrencyLimit
-        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: DatatypeElephino = state.gap1ndex
-        gap1ndexCeiling: DatatypeElephino = state.gap1ndexCeiling
-        groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
-        indexDimension: DatatypeLeavesTotal = state.indexDimension
-        indexLeaf: DatatypeLeavesTotal = state.indexLeaf
-        indexMiniGap: DatatypeElephino = state.indexMiniGap
-        leaf1ndex: DatatypeLeavesTotal = state.leaf1ndex
-        leafConnectee: DatatypeLeavesTotal = state.leafConnectee
-        taskIndex: DatatypeLeavesTotal = state.taskIndex
-        mapShape, leavesTotal, taskDivisions, concurrencyLimit, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, foldsTotal, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, taskIndex = countSequential(mapShape, leavesTotal, taskDivisions, concurrencyLimit, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, foldsTotal, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, taskIndex)
-        state = ComputationState(mapShape=mapShape, leavesTotal=leavesTotal, taskDivisions=taskDivisions, concurrencyLimit=concurrencyLimit, 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)
-    return state