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

mapFolding/someAssemblyRequired/synthesizeNumbaJob.py

@@ -18,7 +18,7 @@ This creates extremely fast, specialized implementations that can be run directl
 as Python scripts or further compiled into standalone executables.
 """
 
-from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal
+from mapFolding import getPathFilenameFoldsTotal, raiseIfNoneGitHubIssueNumber3, The
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
 	be,
@@ -29,15 +29,15 @@ from mapFolding.someAssemblyRequired import (
 	Make,
 	NodeChanger,
 	NodeTourist,
+	str_nameDOTname,
 	Then,
 )
-from mapFolding.someAssemblyRequired.toolboxNumba import parametersNumbaLight, SpicesJobNumba, decorateCallableWithNumba
-from mapFolding.someAssemblyRequired.transformationTools import extractFunctionDef, write_astModule, makeInitializedComputationState
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJob
-from mapFolding import The, raiseIfNoneGitHubIssueNumber3, getFoldsTotalKnown
-from typing import cast
-from Z0Z_tools import autoDecodingRLE
+from mapFolding.someAssemblyRequired.toolboxNumba import parametersNumbaLight, SpicesJobNumba, decorateCallableWithNumba
+from mapFolding.someAssemblyRequired.transformationTools import dictionaryEstimates, extractFunctionDef, write_astModule, 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`."""
 
@@ -150,7 +150,7 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 					case 'scalar':
 						ImaAnnAssign.value.args[0].value = int(job.state.__dict__[ast_arg.arg]) # type: ignore
 					case 'array':
-						dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[ast_arg.arg], addSpaces=True)
+						dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[ast_arg.arg], True)
 						dataAs_astExpr: ast.expr = cast(ast.Expr, ast.parse(dataAsStrRLE).body[0]).value
 						ImaAnnAssign.value.args = [dataAs_astExpr] # type: ignore
 					case _:
@@ -228,9 +228,9 @@ if __name__ == '__main__':
 	writeStream = open('{job.pathFilenameFoldsTotal.as_posix()}', 'w')
 	writeStream.write(str(foldsTotal))
 	writeStream.close()
-	from mapFolding.oeis import getFoldsTotalKnown
-	print(foldsTotal == getFoldsTotalKnown({job.state.mapShape}))
 """
+	# 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)
@@ -238,38 +238,37 @@ if __name__ == '__main__':
 
 	ingredientsCount = move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsCount, job)
 
-	Z0Z_Identifier = 'DatatypeLeavesTotal'
-	Z0Z_type = 'uint8'
-	ingredientsModule.imports.addImportFrom_asStr('numba', Z0Z_type)
-	Z0Z_statement = Make.Assign([Make.Name(Z0Z_Identifier, ast.Store())], Make.Name(Z0Z_type))
-	ingredientsModule.appendPrologue(statement=Z0Z_statement)
+	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='uint16'),
+		DatatypeConfig(fml='DatatypeElephino', Z0Z_module='numba', Z0Z_type_name='uint16'),
+		DatatypeConfig(fml='DatatypeFoldsTotal', Z0Z_module='numba', Z0Z_type_name='int64'),
+	]
+
+	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)
 
-	Z0Z_Identifier = 'DatatypeElephino'
-	Z0Z_type = 'uint8'
-	ingredientsModule.imports.addImportFrom_asStr('numba', Z0Z_type)
-	Z0Z_statement = Make.Assign([Make.Name(Z0Z_Identifier, ast.Store())], Make.Name(Z0Z_type))
-	ingredientsModule.appendPrologue(statement=Z0Z_statement)
+	ingredientsCount.imports.removeImportFromModule('mapFolding.theSSOT')
 
-	Z0Z_Identifier = 'DatatypeFoldsTotal'
-	Z0Z_type = 'int64'
-	ingredientsModule.imports.addImportFrom_asStr('numba', Z0Z_type)
-	Z0Z_statement = Make.Assign([Make.Name(Z0Z_Identifier, ast.Store())], Make.Name(Z0Z_type))
-	ingredientsModule.appendPrologue(statement=Z0Z_statement)
+	listNumPyTypeConfigs = [
+		DatatypeConfig(fml='Array1DLeavesTotal', Z0Z_module='numpy', Z0Z_type_name='uint16', 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='uint16', Z0Z_asname='Array3D'),
+	]
 
-	ingredientsCount.imports.removeImportFromModule('mapFolding.theSSOT')
-	Z0Z_module = 'numpy'
-	Z0Z_asname = 'Array1DLeavesTotal'
-	ingredientsCount.imports.removeImportFrom(Z0Z_module, None, Z0Z_asname)
-	Z0Z_type_name = 'uint8'
-	ingredientsCount.imports.addImportFrom_asStr(Z0Z_module, Z0Z_type_name, Z0Z_asname)
-	Z0Z_asname = 'Array1DElephino'
-	ingredientsCount.imports.removeImportFrom(Z0Z_module, None, Z0Z_asname)
-	Z0Z_type_name = 'uint8'
-	ingredientsCount.imports.addImportFrom_asStr(Z0Z_module, Z0Z_type_name, Z0Z_asname)
-	Z0Z_asname = 'Array3D'
-	ingredientsCount.imports.removeImportFrom(Z0Z_module, None, Z0Z_asname)
-	Z0Z_type_name = 'uint8'
-	ingredientsCount.imports.addImportFrom_asStr(Z0Z_module, Z0Z_type_name, Z0Z_asname)
+	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:`
@@ -300,9 +299,10 @@ if __name__ == '__main__':
 	"""
 
 if __name__ == '__main__':
-	mapShape = (1,24)
+	mapShape = (2,2,2,2,2,2,2,2)
 	state = makeInitializedComputationState(mapShape)
-	foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal
+	# foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal
+	foldsTotalEstimated = dictionaryEstimates[state.mapShape] // state.leavesTotal
 	pathModule = PurePosixPath(The.pathPackage, 'jobs')
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
 	aJob = RecipeJob(state, foldsTotalEstimated, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)

mapFolding/someAssemblyRequired/toolboxNumba.py

@@ -16,8 +16,8 @@ performance improvements while preserving code semantics and correctness.
 """
 
 from collections.abc import Callable, Sequence
-from mapFolding.someAssemblyRequired import Make, NodeTourist, RecipeSynthesizeFlow, Then, ast_Identifier, str_nameDOTname, IngredientsFunction
-from mapFolding.someAssemblyRequired.transformationTools import ( makeNewFlow, write_astModule, )
+from mapFolding.someAssemblyRequired import ast_Identifier, be, IngredientsFunction, Make, NodeTourist, RecipeSynthesizeFlow, str_nameDOTname, Then
+from mapFolding.someAssemblyRequired.transformationTools import makeNewFlow, write_astModule
 from numba.core.compiler import CompilerBase as numbaCompilerBase
 from typing import Any, cast, Final, TYPE_CHECKING, TypeGuard
 import ast
@@ -154,14 +154,6 @@ class SpicesJobNumba:
 	parametersNumba: ParametersNumba = dataclasses.field(default_factory=ParametersNumba) # type: ignore
 
 # Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
-class be:
-	@staticmethod
-	def Call(node: ast.AST) -> TypeGuard[ast.Call]:
-		return isinstance(node, ast.Call)
-	@staticmethod
-	def Return(node: ast.AST) -> TypeGuard[ast.Return]:
-		return isinstance(node, ast.Return)
-
 def makeNumbaFlow(numbaFlow: RecipeSynthesizeFlow) -> None:
 	"""
 	Transform standard Python algorithm code into optimized Numba implementations.

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
 
@@ -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)