mapFolding 0.11.0__py3-none-any.whl → 0.11.2__py3-none-any.whl

mapFolding/someAssemblyRequired/transformationTools.py

@@ -18,10 +18,9 @@ readable, maintainable implementations to highly optimized versions while preser
 logical structure and correctness.
 """
 
-from astToolkit.transformationTools import ( inlineFunctionDef as inlineFunctionDef, removeUnusedParameters as removeUnusedParameters, write_astModule as write_astModule, )
-from collections.abc import Callable, Mapping
-from copy import deepcopy
-from mapFolding.beDRY import outfitCountFolds
+from collections.abc import Callable
+from astToolkit import ClassIsAndAttribute
+from mapFolding import outfitCountFolds, ComputationState, The, getPathFilenameFoldsTotal
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
 	astModuleToIngredientsFunction,
@@ -33,19 +32,19 @@ from mapFolding.someAssemblyRequired import (
 	importLogicalPath2Callable,
 	IngredientsFunction,
 	IngredientsModule,
+	inlineFunctionDef,
 	LedgerOfImports,
 	Make,
 	NodeChanger,
 	NodeTourist,
 	parseLogicalPath2astModule,
 	RecipeSynthesizeFlow,
+	removeUnusedParameters,
 	ShatteredDataclass,
 	str_nameDOTname,
 	Then,
-	个,
+	unparseFindReplace,
 )
-from mapFolding.theSSOT import ComputationState, The
-from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal
 from os import PathLike
 from pathlib import Path, PurePath
 from typing import Any, Literal, overload
@@ -116,8 +115,8 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclas
 		instance_Identifier: The variable name to use for the dataclass instance in generated code.
 
 	Returns:
-		A ShatteredDataclass containing AST representations of all dataclass components,
-		with imports, field definitions, annotations, and repackaging code.
+		shatteredDataclass: A ShatteredDataclass containing AST representations of all dataclass components,
+			with imports, field definitions, annotations, and repackaging code.
 
 	Raises:
 		ValueError: If the dataclass cannot be found in the specified module or if no counting variable is identified in the dataclass.
@@ -136,7 +135,9 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclas
 			countingVariable = dictionaryDeReConstruction[aField.name].name
 
 	if countingVariable is None:
-		raise ValueError(f"I could not find the counting variable in `{dataclass_Identifier = }` in `{logicalPathModule = }`.")
+		import warnings
+		warnings.warn(message=f"I could not find the counting variable in `{dataclass_Identifier = }` in `{logicalPathModule = }`.", category=UserWarning)
+		raise Exception
 
 	shatteredDataclass = ShatteredDataclass(
 		countingVariableAnnotation=dictionaryDeReConstruction[countingVariable].astAnnotation,
@@ -230,7 +231,7 @@ def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
 	if recipeFlow.removeDataclassParallel:
 		ingredientsParallel.astFunctionDef.args = Make.arguments(args=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
 
-		ingredientsParallel.astFunctionDef = Z0Z_lameFindReplace(ingredientsParallel.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
+		ingredientsParallel.astFunctionDef = unparseFindReplace(ingredientsParallel.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
 
 		ingredientsParallel = removeUnusedParameters(ingredientsParallel)
 
@@ -257,7 +258,7 @@ def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
 		changeReturnParallelCallable = NodeChanger(Be.Return, Then.replaceWith(Make.Return(shatteredDataclass.countingVariableName)))
 		ingredientsParallel.astFunctionDef.returns = shatteredDataclass.countingVariableAnnotation
 
-		unpack4parallelCallable = NodeChanger(IfThis.isAssignAndValueIs(IfThis.isCallAttributeNamespace_Identifier(recipeFlow.concurrencyManagerNamespace, recipeFlow.concurrencyManagerIdentifier)), Then.insertThisAbove(shatteredDataclass.listUnpack))
+		unpack4parallelCallable = NodeChanger(ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCallAttributeNamespace_Identifier(recipeFlow.concurrencyManagerNamespace, recipeFlow.concurrencyManagerIdentifier)), Then.insertThisAbove(shatteredDataclass.listUnpack))
 
 		unpack4parallelCallable.visit(ingredientsDispatcher.astFunctionDef)
 		replaceCall2concurrencyManager.visit(ingredientsDispatcher.astFunctionDef)
@@ -274,14 +275,14 @@ def removeDataclassFromFunction(ingredientsTarget: IngredientsFunction, shattere
 	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)
+	ingredientsTarget.astFunctionDef = unparseFindReplace(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([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 = NodeChanger(ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCall_Identifier(targetCallableIdentifier)), Then.replaceWith(Make.Assign([shatteredDataclass.fragments4AssignmentOrParameters], value=astCallTargetCallable)))
+	unpack4targetCallable = NodeChanger(ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCall_Identifier(targetCallableIdentifier)), Then.insertThisAbove(shatteredDataclass.listUnpack))
+	repack4targetCallable = NodeChanger(ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCall_Identifier(targetCallableIdentifier)), Then.insertThisBelow([shatteredDataclass.repack]))
 	replaceAssignTargetCallable.visit(ingredientsCaller.astFunctionDef)
 	unpack4targetCallable.visit(ingredientsCaller.astFunctionDef)
 	repack4targetCallable.visit(ingredientsCaller.astFunctionDef)
@@ -294,37 +295,3 @@ dictionaryEstimates: dict[tuple[int, ...], int] = {
 	(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.unparseIs(nodeFind), Then.replaceWith(nodeReplace)).visit(newTree)
-
-		if ast.unparse(newTree) == ast.unparse(astTree):
-			keepGoing = False
-		else:
-			astTree = deepcopy(newTree)
-	return newTree

mapFolding/syntheticModules/countParallel.py

@@ -0,0 +1,98 @@
+from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
+from copy import deepcopy
+from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3D, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, ParallelMapFoldingState
+from multiprocessing import set_start_method as multiprocessing_set_start_method
+from numba import jit
+if __name__ == '__main__':
+    multiprocessing_set_start_method('spawn')
+
+@jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
+def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, connectionGraph: Array3D, dimensionsTotal: DatatypeLeavesTotal, leavesTotal: DatatypeLeavesTotal, taskDivisions: DatatypeLeavesTotal, taskIndex: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3D, DatatypeLeavesTotal, 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:
+                            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
+                if not dimensionsUnconstrained:
+                    indexLeaf = 0
+                    while indexLeaf < leaf1ndex:
+                        gapsWhere[gap1ndexCeiling] = indexLeaf
+                        gap1ndexCeiling += 1
+                        indexLeaf += 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
+    return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal, taskDivisions, taskIndex)
+
+def unRepackParallelMapFoldingState(state: ParallelMapFoldingState) -> ParallelMapFoldingState:
+    mapShape: tuple[DatatypeLeavesTotal, ...] = state.mapShape
+    groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
+    gap1ndex: DatatypeElephino = state.gap1ndex
+    gap1ndexCeiling: DatatypeElephino = state.gap1ndexCeiling
+    indexDimension: DatatypeLeavesTotal = state.indexDimension
+    indexLeaf: DatatypeLeavesTotal = state.indexLeaf
+    indexMiniGap: DatatypeElephino = state.indexMiniGap
+    leaf1ndex: DatatypeLeavesTotal = state.leaf1ndex
+    leafConnectee: DatatypeLeavesTotal = state.leafConnectee
+    dimensionsUnconstrained: DatatypeLeavesTotal = state.dimensionsUnconstrained
+    countDimensionsGapped: Array1DLeavesTotal = state.countDimensionsGapped
+    gapRangeStart: Array1DElephino = state.gapRangeStart
+    gapsWhere: Array1DLeavesTotal = state.gapsWhere
+    leafAbove: Array1DLeavesTotal = state.leafAbove
+    leafBelow: Array1DLeavesTotal = state.leafBelow
+    connectionGraph: Array3D = state.connectionGraph
+    dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
+    leavesTotal: DatatypeLeavesTotal = state.leavesTotal
+    taskDivisions: DatatypeLeavesTotal = state.taskDivisions
+    taskIndex: DatatypeLeavesTotal = state.taskIndex
+    groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal, taskDivisions, taskIndex = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal, taskDivisions, taskIndex)
+    state = ParallelMapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, taskDivisions=taskDivisions, taskIndex=taskIndex)
+    return state
+
+def doTheNeedful(state: ParallelMapFoldingState, concurrencyLimit: int) -> tuple[int, list[ParallelMapFoldingState]]:
+    stateParallel = deepcopy(state)
+    listStatesParallel: list[ParallelMapFoldingState] = [stateParallel] * stateParallel.taskDivisions
+    groupsOfFoldsTotal: int = 0
+    dictionaryConcurrency: dict[int, ConcurrentFuture[ParallelMapFoldingState]] = {}
+    with ProcessPoolExecutor(concurrencyLimit) as concurrencyManager:
+        for indexSherpa in range(stateParallel.taskDivisions):
+            state = deepcopy(stateParallel)
+            state.taskIndex = indexSherpa
+            dictionaryConcurrency[indexSherpa] = concurrencyManager.submit(unRepackParallelMapFoldingState, state)
+        for indexSherpa in range(stateParallel.taskDivisions):
+            listStatesParallel[indexSherpa] = dictionaryConcurrency[indexSherpa].result()
+            groupsOfFoldsTotal += listStatesParallel[indexSherpa].groupsOfFolds
+    foldsTotal: int = groupsOfFoldsTotal * stateParallel.leavesTotal
+    return (foldsTotal, listStatesParallel)

mapFolding/syntheticModules/dataPacking.py

@@ -1,7 +1,7 @@
 from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3D, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
 from mapFolding.syntheticModules.theorem2Numba import count
 
-def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+def sequential(state: MapFoldingState) -> MapFoldingState:
     mapShape: tuple[DatatypeLeavesTotal, ...] = state.mapShape
     groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
     gap1ndex: DatatypeElephino = state.gap1ndex