mapFolding 0.9.1__py3-none-any.whl → 0.9.3__py3-none-any.whl

mapFolding/someAssemblyRequired/transformationTools.py

@@ -119,7 +119,7 @@ def makeDictionaryFunctionDef(module: ast.Module) -> dict[ast_Identifier, ast.Fu
 		A dictionary mapping function identifiers to their AST function definition nodes.
 	"""
 	dictionaryIdentifier2FunctionDef: dict[ast_Identifier, ast.FunctionDef] = {}
-	NodeTourist(lambda node: isinstance(node, ast.FunctionDef), Then.updateKeyValueIn(DOT.name, Then.extractIt, dictionaryIdentifier2FunctionDef)).visit(module) # type: ignore
+	NodeTourist(be.FunctionDef, Then.updateKeyValueIn(DOT.name, Then.extractIt, dictionaryIdentifier2FunctionDef)).visit(module)
 	return dictionaryIdentifier2FunctionDef
 
 def inlineFunctionDef(identifierToInline: ast_Identifier, module: ast.Module) -> ast.FunctionDef:
@@ -148,7 +148,7 @@ def inlineFunctionDef(identifierToInline: ast_Identifier, module: ast.Module) ->
 		raise ValueError(f"FunctionDefToInline not found in dictionaryIdentifier2FunctionDef: {identifierToInline = }") from ERRORmessage
 
 	listIdentifiersCalledFunctions: list[ast_Identifier] = []
-	findIdentifiersToInline = NodeTourist(ifThis.isCallToName, lambda node: Then.appendTo(listIdentifiersCalledFunctions)(DOT.id(DOT.func(node)))) # type: ignore
+	findIdentifiersToInline = NodeTourist(findThis = ifThis.isCallToName, doThat = grab.funcDOTidAttribute(Then.appendTo(listIdentifiersCalledFunctions)))
 	findIdentifiersToInline.visit(FunctionDefToInline)
 
 	dictionary4Inlining: dict[ast_Identifier, ast.FunctionDef] = {}
@@ -169,7 +169,8 @@ def inlineFunctionDef(identifierToInline: ast_Identifier, module: ast.Module) ->
 				if NodeTourist(ifThis.matchesMeButNotAnyDescendant(ifThis.isCall_Identifier(identifier)), Then.extractIt).captureLastMatch(module) is not None:
 					FunctionDefTarget = dictionaryFunctionDef[identifier]
 					if len(FunctionDefTarget.body) == 1:
-						inliner = NodeChanger(ifThis.isCall_Identifier(identifier), Then.replaceWith(FunctionDefTarget.body[0].value)) # type: ignore
+						replacement = NodeTourist(be.Return, Then.extractIt(DOT.value)).captureLastMatch(FunctionDefTarget)
+						inliner = NodeChanger(ifThis.isCall_Identifier(identifier), Then.replaceWith(replacement))
 						for astFunctionDef in dictionary4Inlining.values():
 							inliner.visit(astFunctionDef)
 					else:
@@ -179,7 +180,8 @@ def inlineFunctionDef(identifierToInline: ast_Identifier, module: ast.Module) ->
 
 	for identifier, FunctionDefTarget in dictionary4Inlining.items():
 		if len(FunctionDefTarget.body) == 1:
-			inliner = NodeChanger(ifThis.isCall_Identifier(identifier), Then.replaceWith(FunctionDefTarget.body[0].value)) # type: ignore
+			replacement = NodeTourist(be.Return, Then.extractIt(DOT.value)).captureLastMatch(FunctionDefTarget)
+			inliner = NodeChanger(ifThis.isCall_Identifier(identifier), Then.replaceWith(replacement))
 			inliner.visit(FunctionDefToInline)
 		else:
 			inliner = NodeChanger(ifThis.isAssignAndValueIs(ifThis.isCall_Identifier(identifier)),Then.replaceWith(FunctionDefTarget.body[0:-1]))
@@ -286,7 +288,7 @@ class DeReConstructField2ast:
 		self.ast_keyword_field__field = Make.keyword(self.name, self.astName)
 		self.ast_nameDOTname = Make.Attribute(Make.Name(dataclassesDOTdataclassInstance_Identifier), self.name)
 
-		sherpa = NodeTourist(ifThis.isAnnAssign_targetIs(ifThis.isName_Identifier(self.name)), Then.extractIt(DOT.annotation)).captureLastMatch(dataclassClassDef) # type: ignore
+		sherpa = NodeTourist(ifThis.isAnnAssign_targetIs(ifThis.isName_Identifier(self.name)), Then.extractIt(DOT.annotation)).captureLastMatch(dataclassClassDef)
 		if sherpa is None: raise raiseIfNoneGitHubIssueNumber3
 		else: self.astAnnotation = sherpa
 
@@ -422,7 +424,7 @@ def write_astModule(ingredients: IngredientsModule, pathFilename: PathLike[Any]
 	4. Optimizes imports using autoflake
 	5. Writes the final source code to the specified file location
 
-	This is typically the final step in the code generation pipeline,
+	This is typically the final step in the code generation assembly line,
 	producing optimized Python modules ready for execution.
 
 	Parameters:
@@ -441,62 +443,25 @@ def write_astModule(ingredients: IngredientsModule, pathFilename: PathLike[Any]
 	if packageName:
 		autoflake_additional_imports.append(packageName)
 	pythonSource = autoflake_fix_code(pythonSource, autoflake_additional_imports, expand_star_imports=False, remove_all_unused_imports=True, remove_duplicate_keys = False, remove_unused_variables = False)
-	# pythonSource = python_minifier.minify(pythonSource)
+	# pythonSource = python_minifier.minify(pythonSource, remove_annotations=False, hoist_literals=False)
 	writeStringToHere(pythonSource, pathFilename)
 
 # END of acceptable classes and functions ======================================================
-def removeUnusedParameters(ingredientsFunction: IngredientsFunction):
+def removeUnusedParameters(ingredientsFunction: IngredientsFunction) -> IngredientsFunction:
 	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)
+	fauxFunctionDef = deepcopy(ingredientsFunction.astFunctionDef)
+	NodeChanger(be.Return, Then.removeIt).visit(fauxFunctionDef)
+	NodeTourist(be.Name, Then.appendTo(listName)).visit(fauxFunctionDef)
 	list_Identifiers: list[ast_Identifier] = [astName.id for astName in listName]
 	list_IdentifiersNotUsed: list[ast_Identifier] = list(set(list_arg_arg) - set(list_Identifiers))
-
-dictionaryEstimates: dict[tuple[int, ...], int] = {
-	(2,2,2,2,2,2,2,2): 798148657152000,
-	(2,21): 776374224866624,
-	(3,15): 824761667826225,
-	(3,3,3,3): 85109616000000000000000000000000,
-	(8,8): 791274195985524900,
-}
-
-# END of marginal classes and functions ======================================================
-def Z0Z_lameFindReplace(astTree: 个, mappingFindReplaceNodes: Mapping[ast.AST, ast.AST]) -> 个:
-	"""
-	Recursively replace AST nodes based on a mapping of find-replace pairs.
-
-	This function applies brute-force node replacement throughout an AST tree
-	by comparing textual representations of nodes. While not the most efficient
-	approach, it provides a reliable way to replace complex nested structures
-	when more precise targeting methods are difficult to implement.
-
-	The function continues replacing nodes until no more changes are detected
-	in the AST's textual representation, ensuring complete replacement throughout
-	the tree structure.
-
-	Parameters:
-		astTree: The AST structure to modify.
-		mappingFindReplaceNodes: A mapping from source nodes to replacement nodes.
-
-	Returns:
-		The modified AST structure with all matching nodes replaced.
-	"""
-	keepGoing = True
-	newTree = deepcopy(astTree)
-
-	while keepGoing:
-		for nodeFind, nodeReplace in mappingFindReplaceNodes.items():
-			NodeChanger(ifThis.Z0Z_unparseIs(nodeFind), Then.replaceWith(nodeReplace)).visit(newTree)
-
-		if ast.unparse(newTree) == ast.unparse(astTree):
-			keepGoing = False
-		else:
-			astTree = deepcopy(newTree)
-	return newTree
+	for arg_Identifier in list_IdentifiersNotUsed:
+		remove_arg = NodeChanger(ifThis.is_arg_Identifier(arg_Identifier), Then.removeIt)
+		remove_arg.visit(ingredientsFunction.astFunctionDef)
+	return ingredientsFunction
 
 def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
-	# TODO a tool to automatically remove unused variables from the ArgumentsSpecification (return, and returns) _might_ be nice.
 	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
 	listAllIngredientsFunctions = [
 	(ingredientsInitialize := astModuleToIngredientsFunction(recipeFlow.source_astModule, recipeFlow.sourceCallableInitialize)),
@@ -537,7 +502,7 @@ def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
 	for ingredients in listAllIngredientsFunctions:
 		for source_Identifier, recipe_Identifier in listFindReplace:
 			updateName = NodeChanger(ifThis.isName_Identifier(source_Identifier) , grab.idAttribute(Then.replaceWith(recipe_Identifier)))
-			update_arg = NodeChanger(ifThis.isArgument_Identifier(source_Identifier), grab.argAttribute(Then.replaceWith(recipe_Identifier)))
+			update_arg = NodeChanger(ifThis.isArgument_Identifier(source_Identifier), grab.argAttribute(Then.replaceWith(recipe_Identifier))) # type: ignore
 			updateName.visit(ingredients.astFunctionDef)
 			update_arg.visit(ingredients.astFunctionDef)
 
@@ -555,26 +520,27 @@ def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
 	# Change callable parameters and Call to the callable at the same time ====
 	# sequentialCallable =========================================================
 	if recipeFlow.removeDataclassSequential:
-		ingredientsSequential.astFunctionDef.args = Make.argumentsSpecification(args=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
-		astCallSequentialCallable = Make.Call(Make.Name(recipeFlow.callableSequential), shatteredDataclass.listName4Parameters)
-		changeReturnSequentialCallable = NodeChanger(be.Return, Then.replaceWith(Make.Return(shatteredDataclass.fragments4AssignmentOrParameters)))
-		ingredientsSequential.astFunctionDef.returns = shatteredDataclass.signatureReturnAnnotation
-		replaceAssignSequentialCallable = NodeChanger(ifThis.isAssignAndValueIs(ifThis.isCall_Identifier(recipeFlow.callableSequential)), Then.replaceWith(Make.Assign(listTargets=[shatteredDataclass.fragments4AssignmentOrParameters], value=astCallSequentialCallable)))
+		ingredientsSequential = removeDataclassFromFunction(ingredientsSequential, shatteredDataclass)
+		ingredientsDispatcher = unpackDataclassCallFunctionRepackDataclass(ingredientsDispatcher, recipeFlow.callableSequential, shatteredDataclass)
 
-		unpack4sequentialCallable = NodeChanger(ifThis.isAssignAndValueIs(ifThis.isCall_Identifier(recipeFlow.callableSequential)), Then.insertThisAbove(shatteredDataclass.listUnpack))
-		repack4sequentialCallable = NodeChanger(ifThis.isAssignAndValueIs(ifThis.isCall_Identifier(recipeFlow.callableSequential)), Then.insertThisBelow([shatteredDataclass.repack]))
-
-		changeReturnSequentialCallable.visit(ingredientsSequential.astFunctionDef)
-		replaceAssignSequentialCallable.visit(ingredientsDispatcher.astFunctionDef)
-		unpack4sequentialCallable.visit(ingredientsDispatcher.astFunctionDef)
-		repack4sequentialCallable.visit(ingredientsDispatcher.astFunctionDef)
-
-		ingredientsSequential.astFunctionDef = Z0Z_lameFindReplace(ingredientsSequential.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
+	if recipeFlow.removeDataclassInitialize:
+		ingredientsInitialize = removeDataclassFromFunction(ingredientsInitialize, shatteredDataclass)
+		ingredientsDispatcher = unpackDataclassCallFunctionRepackDataclass(ingredientsDispatcher, recipeFlow.callableInitialize, shatteredDataclass)
 
 	# parallelCallable =========================================================
 	if recipeFlow.removeDataclassParallel:
 		ingredientsParallel.astFunctionDef.args = Make.argumentsSpecification(args=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
-		replaceCall2concurrencyManager = NodeChanger(ifThis.isCallAttributeNamespace_Identifier(recipeFlow.concurrencyManagerNamespace, recipeFlow.concurrencyManagerIdentifier), Then.replaceWith(Make.Call(Make.Attribute(Make.Name(recipeFlow.concurrencyManagerNamespace), recipeFlow.concurrencyManagerIdentifier), listArguments=[Make.Name(recipeFlow.callableParallel)] + shatteredDataclass.listName4Parameters)))
+
+		ingredientsParallel.astFunctionDef = Z0Z_lameFindReplace(ingredientsParallel.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
+
+		ingredientsParallel = removeUnusedParameters(ingredientsParallel)
+
+		list_argCuzMyBrainRefusesToThink = ingredientsParallel.astFunctionDef.args.args + ingredientsParallel.astFunctionDef.args.posonlyargs + ingredientsParallel.astFunctionDef.args.kwonlyargs
+		list_arg_arg: list[ast_Identifier] = [ast_arg.arg for ast_arg in list_argCuzMyBrainRefusesToThink]
+
+		listParameters = [parameter for parameter in shatteredDataclass.listName4Parameters if parameter.id in list_arg_arg]
+
+		replaceCall2concurrencyManager = NodeChanger(ifThis.isCallAttributeNamespace_Identifier(recipeFlow.concurrencyManagerNamespace, recipeFlow.concurrencyManagerIdentifier), Then.replaceWith(Make.Call(Make.Attribute(Make.Name(recipeFlow.concurrencyManagerNamespace), recipeFlow.concurrencyManagerIdentifier), listArguments=[Make.Name(recipeFlow.callableParallel)] + listParameters)))
 
 		# NOTE I am dissatisfied with this logic for many reasons, including that it requires separate NodeCollector and NodeReplacer instances.
 		astCallConcurrencyResult: list[ast.Call] = []
@@ -591,16 +557,74 @@ def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
 		replaceCall2concurrencyManager.visit(ingredientsDispatcher.astFunctionDef)
 		changeReturnParallelCallable.visit(ingredientsParallel.astFunctionDef)
 
-		ingredientsParallel.astFunctionDef = Z0Z_lameFindReplace(ingredientsParallel.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
-
 	# Module-level transformations ===========================================================
 	ingredientsModuleNumbaUnified = IngredientsModule(ingredientsFunction=listAllIngredientsFunctions, imports=LedgerOfImports(recipeFlow.source_astModule))
 	ingredientsModuleNumbaUnified.removeImportFromModule('numpy')
 
 	return ingredientsModuleNumbaUnified
 
+def removeDataclassFromFunction(ingredientsTarget: IngredientsFunction, shatteredDataclass: ShatteredDataclass) -> IngredientsFunction:
+	ingredientsTarget.astFunctionDef.args = Make.argumentsSpecification(args=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
+	ingredientsTarget.astFunctionDef.returns = shatteredDataclass.signatureReturnAnnotation
+	changeReturnCallable = NodeChanger(be.Return, Then.replaceWith(Make.Return(shatteredDataclass.fragments4AssignmentOrParameters)))
+	changeReturnCallable.visit(ingredientsTarget.astFunctionDef)
+	ingredientsTarget.astFunctionDef = Z0Z_lameFindReplace(ingredientsTarget.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
+	return ingredientsTarget
+
+def unpackDataclassCallFunctionRepackDataclass(ingredientsCaller: IngredientsFunction, targetCallableIdentifier: ast_Identifier, shatteredDataclass: ShatteredDataclass) -> IngredientsFunction:
+	astCallTargetCallable = Make.Call(Make.Name(targetCallableIdentifier), shatteredDataclass.listName4Parameters)
+	replaceAssignTargetCallable = NodeChanger(ifThis.isAssignAndValueIs(ifThis.isCall_Identifier(targetCallableIdentifier)), Then.replaceWith(Make.Assign(listTargets=[shatteredDataclass.fragments4AssignmentOrParameters], value=astCallTargetCallable)))
+	unpack4targetCallable = NodeChanger(ifThis.isAssignAndValueIs(ifThis.isCall_Identifier(targetCallableIdentifier)), Then.insertThisAbove(shatteredDataclass.listUnpack))
+	repack4targetCallable = NodeChanger(ifThis.isAssignAndValueIs(ifThis.isCall_Identifier(targetCallableIdentifier)), Then.insertThisBelow([shatteredDataclass.repack]))
+	replaceAssignTargetCallable.visit(ingredientsCaller.astFunctionDef)
+	unpack4targetCallable.visit(ingredientsCaller.astFunctionDef)
+	repack4targetCallable.visit(ingredientsCaller.astFunctionDef)
+	return ingredientsCaller
+
 def getIt(astCallConcurrencyResult: list[ast.Call]) -> Callable[[ast.AST], ast.AST]:
 	def workhorse(node: ast.AST) -> ast.AST:
 		NodeTourist(be.Call, Then.appendTo(astCallConcurrencyResult)).visit(node)
 		return node
 	return workhorse
+
+dictionaryEstimates: dict[tuple[int, ...], int] = {
+	(2,2,2,2,2,2,2,2): 798148657152000,
+	(2,21): 776374224866624,
+	(3,15): 824761667826225,
+	(3,3,3,3): 85109616000000000000000000000000,
+	(8,8): 791274195985524900,
+}
+
+# END of marginal classes and functions ======================================================
+def Z0Z_lameFindReplace(astTree: 个, mappingFindReplaceNodes: Mapping[ast.AST, ast.AST]) -> 个:
+	"""
+	Recursively replace AST nodes based on a mapping of find-replace pairs.
+
+	This function applies brute-force node replacement throughout an AST tree
+	by comparing textual representations of nodes. While not the most efficient
+	approach, it provides a reliable way to replace complex nested structures
+	when more precise targeting methods are difficult to implement.
+
+	The function continues replacing nodes until no more changes are detected
+	in the AST's textual representation, ensuring complete replacement throughout
+	the tree structure.
+
+	Parameters:
+		astTree: The AST structure to modify.
+		mappingFindReplaceNodes: A mapping from source nodes to replacement nodes.
+
+	Returns:
+		The modified AST structure with all matching nodes replaced.
+	"""
+	keepGoing = True
+	newTree = deepcopy(astTree)
+
+	while keepGoing:
+		for nodeFind, nodeReplace in mappingFindReplaceNodes.items():
+			NodeChanger(ifThis.Z0Z_unparseIs(nodeFind), Then.replaceWith(nodeReplace)).visit(newTree)
+
+		if ast.unparse(newTree) == ast.unparse(astTree):
+			keepGoing = False
+		else:
+			astTree = deepcopy(newTree)
+	return newTree

mapFolding/syntheticModules/numbaCount.py

@@ -4,7 +4,7 @@ from mapFolding.theSSOT import Array1DElephino, Array1DFoldsTotal, Array1DLeaves
 from numba import jit
 
 def countInitialize(state: ComputationState) -> ComputationState:
-    while state.leaf1ndex > 0:
+    while state.gap1ndex == 0:
         if state.leaf1ndex <= 1 or state.leafBelow[0] == 1:
             state.dimensionsUnconstrained = state.dimensionsTotal
             state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
@@ -42,12 +42,10 @@ def countInitialize(state: ComputationState) -> ComputationState:
             state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
             state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
             state.leaf1ndex += 1
-        if state.gap1ndex > 0:
-            break
     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(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: DatatypeLeavesTotal, gap1ndexCeiling: DatatypeElephino, groupsOfFolds: DatatypeFoldsTotal, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeElephino, taskIndex: DatatypeLeavesTotal) -> DatatypeFoldsTotal:
+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:
@@ -92,7 +90,7 @@ def countParallel(mapShape: tuple[DatatypeLeavesTotal, ...], leavesTotal: Dataty
     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: DatatypeLeavesTotal, gap1ndexCeiling: DatatypeElephino, groupsOfFolds: DatatypeFoldsTotal, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeElephino, taskIndex: DatatypeLeavesTotal) -> tuple[tuple[DatatypeLeavesTotal, ...], DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, Array3D, DatatypeLeavesTotal, Array1DLeavesTotal, DatatypeLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array1DFoldsTotal, DatatypeFoldsTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal]:
+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:
@@ -124,7 +122,7 @@ def countSequential(mapShape: tuple[DatatypeLeavesTotal, ...], leavesTotal: Data
             leaf1ndex -= 1
             leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]
             leafAbove[leafBelow[leaf1ndex]] = leafAbove[leaf1ndex]
-        if groupsOfFolds and leaf1ndex == 3:
+        if leaf1ndex == 3 and groupsOfFolds:
             groupsOfFolds *= 2
             break
         if leaf1ndex > 0:
@@ -161,16 +159,16 @@ def doTheNeedful(state: ComputationState) -> ComputationState:
                 leafBelow: Array1DLeavesTotal = state.leafBelow
                 foldGroups: Array1DFoldsTotal = state.foldGroups
                 foldsTotal: DatatypeFoldsTotal = state.foldsTotal
-                gap1ndex: DatatypeLeavesTotal = state.gap1ndex
+                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: DatatypeElephino = state.leafConnectee
+                leafConnectee: DatatypeLeavesTotal = state.leafConnectee
                 taskIndex: DatatypeLeavesTotal = state.taskIndex
-                dictionaryConcurrency[indexSherpa] = concurrencyManager.submit(countParallel, mapShape, leavesTotal, taskDivisions, concurrencyLimit, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, foldsTotal, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, 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
@@ -189,14 +187,14 @@ def doTheNeedful(state: ComputationState) -> ComputationState:
         leafBelow: Array1DLeavesTotal = state.leafBelow
         foldGroups: Array1DFoldsTotal = state.foldGroups
         foldsTotal: DatatypeFoldsTotal = state.foldsTotal
-        gap1ndex: DatatypeLeavesTotal = state.gap1ndex
+        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: DatatypeElephino = state.leafConnectee
+        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)

mapFolding/theDao.py

@@ -1,23 +1,22 @@
 """
 Core computational algorithm for map folding counting and enumeration.
 
-This module implements the core algorithms for enumerating and counting the various ways
-a rectangular map can be folded. It uses a functional state-transformation approach, where
-each function performs a specific state mutation and returns the updated state. The module
-provides three main counting algorithms:
-
-1. countInitialize: Sets up the initial state for computation
-2. countSequential: Processes the folding computation sequentially
-3. countParallel: Distributes the computation across multiple processes
-
-All algorithms operate on a ComputationState object that tracks the folding process, including:
-- A "leaf" is a unit square in the map
-- A "gap" is a potential position where a new leaf can be folded
-- Connections track how leaves can connect above/below each other
-- Leaves are enumerated starting from 1, not 0; hence, leaf1ndex not leafIndex
-
-The doTheNeedful function is the main entry point that orchestrates the computation strategy
-based on task divisions and concurrency parameters.
+This module implements the core algorithms for enumerating and counting the various ways a rectangular map can be
+folded. It uses a functional state-transformation approach, where each function performs a specific state mutation and
+returns the updated state. The module provides three main counting algorithms:
+
+1. `countInitialize`: Sets up the initial state for computation.
+2. `countSequential`: Processes the folding computation sequentially.
+3. `countParallel`: Distributes the computation across multiple processes.
+
+All algorithms operate on a `ComputationState` object that tracks the folding process, including:
+- A "leaf" is a unit square in the map.
+- A "gap" is a potential position where a new leaf can be folded.
+- Connections track how leaves can connect above/below each other.
+- Leaves are enumerated starting from 1, not 0; hence, `leaf1ndex` not `leafIndex`.
+
+The `doTheNeedful` function is the main entry point that orchestrates the computation strategy based on task divisions and
+concurrency parameters.
 """
 from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
 from copy import deepcopy
@@ -144,7 +143,7 @@ def updateLeafConnectee(state: ComputationState) -> ComputationState:
 	return state
 
 def countInitialize(state: ComputationState) -> ComputationState:
-	while activeLeafGreaterThan0(state):
+	while state.gap1ndex == 0:
 		if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
 				state = initializeVariablesToFindGaps(state)
 				while loopUpToDimensionsTotal(state):
@@ -164,8 +163,6 @@ def countInitialize(state: ComputationState) -> ComputationState:
 					state = incrementIndexMiniGap(state)
 		if thereIsAnActiveLeaf(state):
 			state = insertLeafAtGap(state)
-		if state.gap1ndex > 0:
-			break
 	return state
 
 def countParallel(state: ComputationState) -> ComputationState:
@@ -218,8 +215,9 @@ def countSequential(state: ComputationState) -> ComputationState:
 					state = incrementIndexMiniGap(state)
 		while noGapsHere(state):
 			state = undoLastLeafPlacement(state)
-		if state.groupsOfFolds and state.leaf1ndex == 3:
+		if state.leaf1ndex == 3 and state.groupsOfFolds:
 			state.groupsOfFolds *= 2
+			# print('break')
 			break
 		if thereIsAnActiveLeaf(state):
 			state = insertLeafAtGap(state)

mapFolding/theDaoOfMapFolding.py

@@ -0,0 +1,142 @@
+from mapFolding.dataBaskets import MapFoldingState
+
+def activeLeafGreaterThan0(state: MapFoldingState) -> bool:
+	return state.leaf1ndex > 0
+
+def activeLeafGreaterThanLeavesTotal(state: MapFoldingState) -> bool:
+	return state.leaf1ndex > state.leavesTotal
+
+def activeLeafIsTheFirstLeaf(state: MapFoldingState) -> bool:
+	return state.leaf1ndex <= 1
+
+def activeLeafIsUnconstrainedInAllDimensions(state: MapFoldingState) -> bool:
+	return not state.dimensionsUnconstrained
+
+def activeLeafUnconstrainedInThisDimension(state: MapFoldingState) -> MapFoldingState:
+	state.dimensionsUnconstrained -= 1
+	return state
+
+def filterCommonGaps(state: MapFoldingState) -> MapFoldingState:
+	state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
+	if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
+		state = incrementActiveGap(state)
+	state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
+	return state
+
+def gapAvailable(state: MapFoldingState) -> bool:
+	return state.leaf1ndex > 0
+
+def incrementActiveGap(state: MapFoldingState) -> MapFoldingState:
+	state.gap1ndex += 1
+	return state
+
+def incrementGap1ndexCeiling(state: MapFoldingState) -> MapFoldingState:
+	state.gap1ndexCeiling += 1
+	return state
+
+def incrementIndexMiniGap(state: MapFoldingState) -> MapFoldingState:
+	state.indexMiniGap += 1
+	return state
+
+def initializeIndexMiniGap(state: MapFoldingState) -> MapFoldingState:
+	state.indexMiniGap = state.gap1ndex
+	return state
+
+def initializeVariablesToFindGaps(state: MapFoldingState) -> MapFoldingState:
+	state.dimensionsUnconstrained = state.dimensionsTotal
+	state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
+	state.indexDimension = 0
+	return state
+
+def insertActiveLeaf(state: MapFoldingState) -> MapFoldingState:
+	state.indexLeaf = 0
+	while state.indexLeaf < state.leaf1ndex:
+		state.gapsWhere[state.gap1ndexCeiling] = state.indexLeaf
+		state.gap1ndexCeiling += 1
+		state.indexLeaf += 1
+	return state
+
+def insertActiveLeafAtGap(state: MapFoldingState) -> MapFoldingState:
+	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
+
+def leafBelowSentinelIs1(state: MapFoldingState) -> bool:
+	return state.leafBelow[0] == 1
+
+def leafConnecteeIsActiveLeaf(state: MapFoldingState) -> bool:
+	return state.leafConnectee == state.leaf1ndex
+
+def lookForGaps(state: MapFoldingState) -> MapFoldingState:
+	state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
+	if state.countDimensionsGapped[state.leafConnectee] == 0:
+		state = incrementGap1ndexCeiling(state)
+	state.countDimensionsGapped[state.leafConnectee] += 1
+	return state
+
+def lookupLeafConnecteeInConnectionGraph(state: MapFoldingState) -> MapFoldingState:
+	state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
+	return state
+
+def loopingLeavesConnectedToActiveLeaf(state: MapFoldingState) -> bool:
+	return state.leafConnectee != state.leaf1ndex
+
+def loopingThroughTheDimensions(state: MapFoldingState) -> bool:
+	return state.indexDimension < state.dimensionsTotal
+
+def loopingToActiveGapCeiling(state: MapFoldingState) -> bool:
+	return state.indexMiniGap < state.gap1ndexCeiling
+
+def noGapsHere(state: MapFoldingState) -> bool:
+	return (state.leaf1ndex > 0) and (state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1])
+
+def tryAnotherLeafConnectee(state: MapFoldingState) -> MapFoldingState:
+	state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
+	return state
+
+def tryNextDimension(state: MapFoldingState) -> MapFoldingState:
+	state.indexDimension += 1
+	return state
+
+def undoLastLeafPlacement(state: MapFoldingState) -> MapFoldingState:
+	state.leaf1ndex -= 1
+	state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
+	state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
+	return state
+
+def count(state: MapFoldingState) -> MapFoldingState:
+	while activeLeafGreaterThan0(state):
+		if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
+			if activeLeafGreaterThanLeavesTotal(state):
+				state.groupsOfFolds += 1
+			else:
+				state = initializeVariablesToFindGaps(state)
+				while loopingThroughTheDimensions(state):
+					state = lookupLeafConnecteeInConnectionGraph(state)
+					if leafConnecteeIsActiveLeaf(state):
+						state = activeLeafUnconstrainedInThisDimension(state)
+					else:
+						while loopingLeavesConnectedToActiveLeaf(state):
+							state = lookForGaps(state)
+							state = tryAnotherLeafConnectee(state)
+					state = tryNextDimension(state)
+				if activeLeafIsUnconstrainedInAllDimensions(state):
+					state = insertActiveLeaf(state)
+				state = initializeIndexMiniGap(state)
+				while loopingToActiveGapCeiling(state):
+					state = filterCommonGaps(state)
+					state = incrementIndexMiniGap(state)
+		while noGapsHere(state):
+			state = undoLastLeafPlacement(state)
+		if gapAvailable(state):
+			state = insertActiveLeafAtGap(state)
+	return state
+
+def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+	state = count(state)
+	return state