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

mapFolding/someAssemblyRequired/Z0Z_makeSomeModules.py

@@ -1,3 +1,5 @@
+from collections.abc import Sequence
+from astToolkit import ClassIsAndAttribute, extractClassDef
 from mapFolding import raiseIfNoneGitHubIssueNumber3, The
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
@@ -9,31 +11,36 @@ from mapFolding.someAssemblyRequired import (
 	IfThis,
 	IngredientsFunction,
 	IngredientsModule,
+	inlineFunctionDef,
 	LedgerOfImports,
 	Make,
 	NodeChanger,
 	NodeTourist,
 	parseLogicalPath2astModule,
 	parsePathFilename2astModule,
-	Then,
+	removeUnusedParameters,
 	str_nameDOTname,
+	Then,
+	write_astModule,
+	DeReConstructField2ast,
+	ShatteredDataclass,
 )
-from mapFolding.someAssemblyRequired.toolboxNumba import decorateCallableWithNumba, parametersNumbaLight
+from mapFolding.someAssemblyRequired.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight
 from mapFolding.someAssemblyRequired.transformationTools import (
-	inlineFunctionDef,
 	removeDataclassFromFunction,
-	removeUnusedParameters,
 	shatter_dataclassesDOTdataclass,
 	unpackDataclassCallFunctionRepackDataclass,
-	write_astModule,
 )
 from pathlib import PurePath
+from Z0Z_tools import importLogicalPath2Callable
 import ast
+import dataclasses
 
 algorithmSourceModuleHARDCODED = 'daoOfMapFolding'
 sourceCallableIdentifierHARDCODED = 'count'
 logicalPathInfixHARDCODED: ast_Identifier = 'syntheticModules'
 theCountingIdentifierHARDCODED: ast_Identifier = 'groupsOfFolds'
+dataPackingModuleIdentifierHARDCODED: ast_Identifier = 'dataPacking'
 
 def makeInitializeGroupsOfFolds() -> None:
 	callableIdentifierHARDCODED = 'initializeGroupsOfFolds'
@@ -118,11 +125,12 @@ def makeDaoOfMapFolding() -> PurePath:
 	doTheNeedful.imports.update(shatteredDataclass.imports)
 	targetCallableIdentifier = daoOfMapFolding.astFunctionDef.name
 	doTheNeedful = unpackDataclassCallFunctionRepackDataclass(doTheNeedful, targetCallableIdentifier, shatteredDataclass)
-	astTuple: ast.Tuple | None = NodeTourist(Be.Return, Then.extractIt(DOT.value)).captureLastMatch(daoOfMapFolding.astFunctionDef)
+	astTuple: ast.Tuple | None = NodeTourist(Be.Return, Then.extractIt(DOT.value)).captureLastMatch(daoOfMapFolding.astFunctionDef) # type: ignore
 	if astTuple is None: raise raiseIfNoneGitHubIssueNumber3
 	astTuple.ctx = ast.Store()
+	ast.Return()
 
-	findThis = IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(targetCallableIdentifier))
+	findThis = ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCall_Identifier(targetCallableIdentifier))
 	doThat = Then.replaceWith(Make.Assign([astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
 	changeAssignCallToTarget = NodeChanger(findThis, doThat)
 	changeAssignCallToTarget.visit(doTheNeedful.astFunctionDef)
@@ -136,6 +144,160 @@ def makeDaoOfMapFolding() -> PurePath:
 
 	return pathFilename
 
+def makeDaoOfMapFoldingParallel() -> PurePath:
+	moduleIdentifierHARDCODED: ast_Identifier = 'countParallel'
+
+	algorithmSourceModule = algorithmSourceModuleHARDCODED
+	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
+	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
+
+	logicalPathInfix = logicalPathInfixHARDCODED
+	moduleIdentifier = moduleIdentifierHARDCODED
+
+	astModule = parseLogicalPath2astModule(logicalPathSourceModule)
+	ingredientsFunction = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule), LedgerOfImports(astModule))
+
+	dataclassName: ast.expr | None = NodeTourist(Be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(ingredientsFunction.astFunctionDef)
+	if dataclassName is None: raise raiseIfNoneGitHubIssueNumber3
+	dataclass_Identifier: ast_Identifier | None = NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
+	if dataclass_Identifier is None: raise raiseIfNoneGitHubIssueNumber3
+
+	dataclassLogicalPathModule = None
+	for moduleWithLogicalPath, listNameTuples in ingredientsFunction.imports.dictionaryImportFrom.items():
+		for nameTuple in listNameTuples:
+			if nameTuple[0] == dataclass_Identifier:
+				dataclassLogicalPathModule = moduleWithLogicalPath
+				break
+		if dataclassLogicalPathModule:
+			break
+	if dataclassLogicalPathModule is None: raise raiseIfNoneGitHubIssueNumber3
+	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef)
+	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
+	shatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclass_Identifier, dataclassInstanceIdentifier)
+
+	# Start add the parallel state fields to the count function ================================================
+	dataclassBaseFields = dataclasses.fields(importLogicalPath2Callable(dataclassLogicalPathModule, dataclass_Identifier))  # pyright: ignore [reportArgumentType]
+	dataclass_IdentifierParallel = 'Parallel' + dataclass_Identifier
+	dataclassFieldsParallel = dataclasses.fields(importLogicalPath2Callable(dataclassLogicalPathModule, dataclass_IdentifierParallel))  # pyright: ignore [reportArgumentType]
+	onlyParallelFields = [field for field in dataclassFieldsParallel if field.name not in [fieldBase.name for fieldBase in dataclassBaseFields]]
+
+	Official_fieldOrder: list[ast_Identifier] = []
+	dictionaryDeReConstruction: dict[ast_Identifier, DeReConstructField2ast] = {}
+
+	dataclassClassDef = extractClassDef(parseLogicalPath2astModule(dataclassLogicalPathModule), dataclass_IdentifierParallel)
+	if not isinstance(dataclassClassDef, ast.ClassDef): raise ValueError(f"I could not find `{dataclass_IdentifierParallel = }` in `{dataclassLogicalPathModule = }`.")
+
+	for aField in onlyParallelFields:
+		Official_fieldOrder.append(aField.name)
+		dictionaryDeReConstruction[aField.name] = DeReConstructField2ast(dataclassLogicalPathModule, dataclassClassDef, dataclassInstanceIdentifier, aField)
+
+	shatteredDataclassParallel = ShatteredDataclass(
+		countingVariableAnnotation=shatteredDataclass.countingVariableAnnotation,
+		countingVariableName=shatteredDataclass.countingVariableName,
+		field2AnnAssign={**shatteredDataclass.field2AnnAssign, **{dictionaryDeReConstruction[field].name: dictionaryDeReConstruction[field].astAnnAssignConstructor for field in Official_fieldOrder}},
+		Z0Z_field2AnnAssign={**shatteredDataclass.Z0Z_field2AnnAssign, **{dictionaryDeReConstruction[field].name: dictionaryDeReConstruction[field].Z0Z_hack for field in Official_fieldOrder}},
+		list_argAnnotated4ArgumentsSpecification=shatteredDataclass.list_argAnnotated4ArgumentsSpecification + [dictionaryDeReConstruction[field].ast_argAnnotated for field in Official_fieldOrder],
+		list_keyword_field__field4init=shatteredDataclass.list_keyword_field__field4init + [dictionaryDeReConstruction[field].ast_keyword_field__field for field in Official_fieldOrder if dictionaryDeReConstruction[field].init],
+		listAnnotations=shatteredDataclass.listAnnotations + [dictionaryDeReConstruction[field].astAnnotation for field in Official_fieldOrder],
+		listName4Parameters=shatteredDataclass.listName4Parameters + [dictionaryDeReConstruction[field].astName for field in Official_fieldOrder],
+		listUnpack=shatteredDataclass.listUnpack + [Make.AnnAssign(dictionaryDeReConstruction[field].astName, dictionaryDeReConstruction[field].astAnnotation, dictionaryDeReConstruction[field].ast_nameDOTname) for field in Official_fieldOrder],
+		map_stateDOTfield2Name={**shatteredDataclass.map_stateDOTfield2Name, **{dictionaryDeReConstruction[field].ast_nameDOTname: dictionaryDeReConstruction[field].astName for field in Official_fieldOrder}},
+		)
+	shatteredDataclassParallel.fragments4AssignmentOrParameters = Make.Tuple(shatteredDataclassParallel.listName4Parameters, ast.Store())
+	shatteredDataclassParallel.repack = Make.Assign([Make.Name(dataclassInstanceIdentifier)], value=Make.Call(Make.Name(dataclass_IdentifierParallel), list_keyword=shatteredDataclassParallel.list_keyword_field__field4init))
+	shatteredDataclassParallel.signatureReturnAnnotation = Make.Subscript(Make.Name('tuple'), Make.Tuple(shatteredDataclassParallel.listAnnotations))
+
+	shatteredDataclassParallel.imports.update(*(dictionaryDeReConstruction[field].ledger for field in Official_fieldOrder))
+	shatteredDataclassParallel.imports.addImportFrom_asStr(dataclassLogicalPathModule, dataclass_IdentifierParallel)
+	shatteredDataclassParallel.imports.update(shatteredDataclass.imports)
+	shatteredDataclassParallel.imports.removeImportFrom(dataclassLogicalPathModule, dataclass_Identifier)
+
+	# End add the parallel state fields to the count function ================================================
+
+	ingredientsFunction.imports.update(shatteredDataclassParallel.imports)
+	ingredientsFunction = removeDataclassFromFunction(ingredientsFunction, shatteredDataclassParallel)
+
+	# Start add the parallel logic to the count function ================================================
+
+	findThis = ClassIsAndAttribute.testIs(ast.While, ClassIsAndAttribute.leftIs(ast.Compare, IfThis.isName_Identifier('leafConnectee')))
+	doThat = Then.extractIt(DOT.body)
+	captureCountGapsCodeBlock: NodeTourist[ast.While, Sequence[ast.stmt]] = NodeTourist(findThis, doThat)
+	countGapsCodeBlock = captureCountGapsCodeBlock.captureLastMatch(ingredientsFunction.astFunctionDef)
+	if countGapsCodeBlock is None: raise raiseIfNoneGitHubIssueNumber3
+
+	thisIsMyTaskIndexCodeBlock = ast.If(ast.BoolOp(ast.Or()
+		, values=[ast.Compare(ast.Name('leaf1ndex'), ops=[ast.NotEq()], comparators=[ast.Name('taskDivisions')])
+				, ast.Compare(ast.BinOp(ast.Name('leafConnectee'), op=ast.Mod(), right=ast.Name('taskDivisions')), ops=[ast.Eq()], comparators=[ast.Name('taskIndex')])])
+	, body=list(countGapsCodeBlock[0:-1]))
+
+	countGapsCodeBlockNew: list[ast.stmt] = [thisIsMyTaskIndexCodeBlock, countGapsCodeBlock[-1]]
+
+	doThat = Grab.bodyAttribute(Then.replaceWith(countGapsCodeBlockNew))
+	NodeChanger(findThis, doThat).visit(ingredientsFunction.astFunctionDef)
+
+	# End add the parallel logic to the count function ================================================
+
+	ingredientsFunction = removeUnusedParameters(ingredientsFunction)
+
+	ingredientsFunction = decorateCallableWithNumba(ingredientsFunction, parametersNumbaLight)
+
+	# Start unpack/repack the dataclass function ================================================
+	sourceCallableIdentifier = The.sourceCallableDispatcher
+
+	unRepackDataclass: IngredientsFunction = astModuleToIngredientsFunction(astModule, sourceCallableIdentifier)
+	unRepackDataclass.astFunctionDef.name = 'unRepack' + dataclass_IdentifierParallel
+	unRepackDataclass.imports.update(shatteredDataclassParallel.imports)
+	findThis = ClassIsAndAttribute.annotationIs(ast.arg, IfThis.isName_Identifier(dataclass_Identifier)) # type: ignore
+	doThat = Grab.annotationAttribute(Grab.idAttribute(Then.replaceWith(dataclass_IdentifierParallel))) # type: ignore
+	NodeChanger(findThis, doThat).visit(unRepackDataclass.astFunctionDef) # type: ignore
+	unRepackDataclass.astFunctionDef.returns = Make.Name(dataclass_IdentifierParallel)
+	targetCallableIdentifier = ingredientsFunction.astFunctionDef.name
+	unRepackDataclass = unpackDataclassCallFunctionRepackDataclass(unRepackDataclass, targetCallableIdentifier, shatteredDataclassParallel)
+
+	astTuple: ast.Tuple | None = NodeTourist(Be.Return, Then.extractIt(DOT.value)).captureLastMatch(ingredientsFunction.astFunctionDef) # type: ignore
+	if astTuple is None: raise raiseIfNoneGitHubIssueNumber3
+	astTuple.ctx = ast.Store()
+	findThis = ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCall_Identifier(targetCallableIdentifier))
+	doThat = Then.replaceWith(Make.Assign([astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
+	changeAssignCallToTarget = NodeChanger(findThis, doThat)
+	changeAssignCallToTarget.visit(unRepackDataclass.astFunctionDef)
+
+	ingredientsDoTheNeedful: IngredientsFunction = IngredientsFunction(
+		astFunctionDef = ast.FunctionDef(name='doTheNeedful'
+			, args=ast.arguments(args=[ast.arg('state', annotation=ast.Name(dataclass_IdentifierParallel)), ast.arg('concurrencyLimit', annotation=ast.Name('int'))])
+			, body=[ast.Assign(targets=[ast.Name('stateParallel', ctx=ast.Store())], value=ast.Call(func=ast.Name('deepcopy'), args=[ast.Name('state')]))
+				, ast.AnnAssign(target=ast.Name('listStatesParallel', ctx=ast.Store()), annotation=ast.Subscript(value=ast.Name('list'), slice=ast.Name(dataclass_IdentifierParallel)), value=ast.BinOp(left=ast.List(elts=[ast.Name('stateParallel')]), op=ast.Mult(), right=ast.Attribute(value=ast.Name('stateParallel'), attr='taskDivisions')), simple=1)
+				, ast.AnnAssign(target=ast.Name('groupsOfFoldsTotal', ctx=ast.Store()), annotation=ast.Name('int'), value=ast.Constant(value=0), simple=1)
+
+				, ast.AnnAssign(target=ast.Name('dictionaryConcurrency', ctx=ast.Store()), annotation=ast.Subscript(value=ast.Name('dict'), slice=ast.Tuple(elts=[ast.Name('int'), ast.Subscript(value=ast.Name('ConcurrentFuture'), slice=ast.Name(dataclass_IdentifierParallel))])), value=ast.Dict(), simple=1)
+				, ast.With(items=[ast.withitem(context_expr=ast.Call(func=ast.Name('ProcessPoolExecutor'), args=[ast.Name('concurrencyLimit')]), optional_vars=ast.Name('concurrencyManager', ctx=ast.Store()))]
+					, body=[ast.For(target=ast.Name('indexSherpa', ctx=ast.Store()), iter=ast.Call(func=ast.Name('range'), args=[ast.Attribute(value=ast.Name('stateParallel'), attr='taskDivisions')])
+							, body=[ast.Assign(targets=[ast.Name('state', ctx=ast.Store())], value=ast.Call(func=ast.Name('deepcopy'), args=[ast.Name('stateParallel')]))
+								, ast.Assign(targets=[ast.Attribute(value=ast.Name('state'), attr='taskIndex', ctx=ast.Store())], value=ast.Name('indexSherpa'))
+								, ast.Assign(targets=[ast.Subscript(value=ast.Name('dictionaryConcurrency'), slice=ast.Name('indexSherpa'), ctx=ast.Store())], value=ast.Call(func=ast.Attribute(value=ast.Name('concurrencyManager'), attr='submit'), args=[ast.Name(unRepackDataclass.astFunctionDef.name), ast.Name('state')]))])
+						, ast.For(target=ast.Name('indexSherpa', ctx=ast.Store()), iter=ast.Call(func=ast.Name('range'), args=[ast.Attribute(value=ast.Name('stateParallel'), attr='taskDivisions')])
+							, body=[ast.Assign(targets=[ast.Subscript(value=ast.Name('listStatesParallel'), slice=ast.Name('indexSherpa'), ctx=ast.Store())], value=ast.Call(func=ast.Attribute(value=ast.Subscript(value=ast.Name('dictionaryConcurrency'), slice=ast.Name('indexSherpa')), attr='result')))
+								, ast.AugAssign(target=ast.Name('groupsOfFoldsTotal', ctx=ast.Store()), op=ast.Add(), value=ast.Attribute(value=ast.Subscript(value=ast.Name('listStatesParallel'), slice=ast.Name('indexSherpa')), attr='groupsOfFolds'))])])
+
+				, ast.AnnAssign(target=ast.Name('foldsTotal', ctx=ast.Store()), annotation=ast.Name('int'), value=ast.BinOp(left=ast.Name('groupsOfFoldsTotal'), op=ast.Mult(), right=ast.Attribute(value=ast.Name('stateParallel'), attr='leavesTotal')), simple=1)
+				, ast.Return(value=ast.Tuple(elts=[ast.Name('foldsTotal'), ast.Name('listStatesParallel')]))]
+			, returns=ast.Subscript(value=ast.Name('tuple'), slice=ast.Tuple(elts=[ast.Name('int'), ast.Subscript(value=ast.Name('list'), slice=ast.Name(dataclass_IdentifierParallel))])))
+		, imports = LedgerOfImports(Make.Module([ast.ImportFrom(module='concurrent.futures', names=[ast.alias(name='Future', asname='ConcurrentFuture'), ast.alias(name='ProcessPoolExecutor')], level=0),
+			ast.ImportFrom(module='copy', names=[ast.alias(name='deepcopy')], level=0),
+			ast.ImportFrom(module='multiprocessing', names=[ast.alias(name='set_start_method', asname='multiprocessing_set_start_method')], level=0),])
+		)
+	)
+
+	ingredientsModule = IngredientsModule([ingredientsFunction, unRepackDataclass, ingredientsDoTheNeedful]
+						, prologue = Make.Module([ast.If(test=ast.Compare(left=ast.Name('__name__'), ops=[ast.Eq()], comparators=[ast.Constant(value='__main__')]), body=[ast.Expr(value=ast.Call(func=ast.Name('multiprocessing_set_start_method'), args=[ast.Constant(value='spawn')]))])])
+	)
+	ingredientsModule.removeImportFromModule('numpy')
+
+	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
+
+	write_astModule(ingredientsModule, pathFilename, The.packageName)
+	return pathFilename
+
 def makeTheorem2() -> PurePath:
 	moduleIdentifierHARDCODED: ast_Identifier = 'theorem2'
 
@@ -168,7 +330,7 @@ def makeTheorem2() -> PurePath:
 	doThat = Then.removeIt
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
-	findThis = IfThis.isAttributeNamespace_IdentifierLessThanOrEqual(dataclassInstanceIdentifier, 'leaf1ndex')
+	findThis = IfThis.isAttributeNamespace_IdentifierLessThanOrEqual0(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Then.removeIt
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
@@ -266,23 +428,25 @@ def numbaOnTheorem2(pathFilenameSource: PurePath) -> ast.ImportFrom:
 	return astImportFrom
 
 def makeUnRePackDataclass(astImportFrom: ast.ImportFrom) -> None:
-	moduleIdentifierHARDCODED: ast_Identifier = 'dataPacking'
+	callableIdentifierHARDCODED: ast_Identifier = 'sequential'
 
 	algorithmSourceModule = algorithmSourceModuleHARDCODED
 	sourceCallableIdentifier = The.sourceCallableDispatcher
 	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
 
 	logicalPathInfix = logicalPathInfixHARDCODED
-	moduleIdentifier = moduleIdentifierHARDCODED
+	moduleIdentifier = dataPackingModuleIdentifierHARDCODED
+	callableIdentifier = callableIdentifierHARDCODED
 
-	doTheNeedful: IngredientsFunction = astModuleToIngredientsFunction(parseLogicalPath2astModule(logicalPathSourceModule), sourceCallableIdentifier)
-	dataclassName: ast.expr | None = NodeTourist(Be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(doTheNeedful.astFunctionDef)
+	ingredientsFunction: IngredientsFunction = astModuleToIngredientsFunction(parseLogicalPath2astModule(logicalPathSourceModule), sourceCallableIdentifier)
+	ingredientsFunction.astFunctionDef.name = callableIdentifier
+	dataclassName: ast.expr | None = NodeTourist(Be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(ingredientsFunction.astFunctionDef)
 	if dataclassName is None: raise raiseIfNoneGitHubIssueNumber3
 	dataclass_Identifier: ast_Identifier | None = NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
 	if dataclass_Identifier is None: raise raiseIfNoneGitHubIssueNumber3
 
 	dataclassLogicalPathModule = None
-	for moduleWithLogicalPath, listNameTuples in doTheNeedful.imports.dictionaryImportFrom.items():
+	for moduleWithLogicalPath, listNameTuples in ingredientsFunction.imports.dictionaryImportFrom.items():
 		for nameTuple in listNameTuples:
 			if nameTuple[0] == dataclass_Identifier:
 				dataclassLogicalPathModule = moduleWithLogicalPath
@@ -290,26 +454,26 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom) -> None:
 		if dataclassLogicalPathModule:
 			break
 	if dataclassLogicalPathModule is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(doTheNeedful.astFunctionDef)
+	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef)
 	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
 	shatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclass_Identifier, dataclassInstanceIdentifier)
 
-	doTheNeedful.imports.update(shatteredDataclass.imports)
-	doTheNeedful.imports.addAst(astImportFrom)
+	ingredientsFunction.imports.update(shatteredDataclass.imports)
+	ingredientsFunction.imports.addAst(astImportFrom)
 	targetCallableIdentifier = astImportFrom.names[0].name
-	doTheNeedful = unpackDataclassCallFunctionRepackDataclass(doTheNeedful, targetCallableIdentifier, shatteredDataclass)
+	ingredientsFunction = unpackDataclassCallFunctionRepackDataclass(ingredientsFunction, targetCallableIdentifier, shatteredDataclass)
 	if astImportFrom.module is None: raise raiseIfNoneGitHubIssueNumber3
 	targetFunctionDef = extractFunctionDef(parseLogicalPath2astModule(astImportFrom.module), targetCallableIdentifier)
 	if targetFunctionDef is None: raise raiseIfNoneGitHubIssueNumber3
-	astTuple: ast.Tuple | None = NodeTourist(Be.Return, Then.extractIt(DOT.value)).captureLastMatch(targetFunctionDef)
+	astTuple: ast.Tuple | None = NodeTourist(Be.Return, Then.extractIt(DOT.value)).captureLastMatch(targetFunctionDef) # type: ignore
 	if astTuple is None: raise raiseIfNoneGitHubIssueNumber3
 	astTuple.ctx = ast.Store()
 
-	findThis = IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(targetCallableIdentifier))
+	findThis = ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCall_Identifier(targetCallableIdentifier))
 	doThat = Then.replaceWith(Make.Assign([astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
-	NodeChanger(findThis, doThat).visit(doTheNeedful.astFunctionDef)
+	NodeChanger(findThis, doThat).visit(ingredientsFunction.astFunctionDef)
 
-	ingredientsModule = IngredientsModule(doTheNeedful)
+	ingredientsModule = IngredientsModule(ingredientsFunction)
 	ingredientsModule.removeImportFromModule('numpy')
 
 	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
@@ -322,4 +486,5 @@ if __name__ == '__main__':
 	pathFilename = trimTheorem2(pathFilename)
 	astImportFrom = numbaOnTheorem2(pathFilename)
 	makeUnRePackDataclass(astImportFrom)
-	makeDaoOfMapFolding()
+	pathFilename = makeDaoOfMapFolding()
+	makeDaoOfMapFoldingParallel()

mapFolding/someAssemblyRequired/__init__.py

@@ -53,9 +53,6 @@ from astToolkit import (
 	extractClassDef as extractClassDef,
 	extractFunctionDef as extractFunctionDef,
 	Grab as Grab,
-	ImaCallToName as ImaCallToName,
-	importLogicalPath2Callable as importLogicalPath2Callable,
-	importPathFilename2Callable as importPathFilename2Callable,
 	IngredientsFunction as IngredientsFunction,
 	IngredientsModule as IngredientsModule,
 	LedgerOfImports as LedgerOfImports,
@@ -67,12 +64,20 @@ from astToolkit import (
 	parsePathFilename2astModule as parsePathFilename2astModule,
 	str_nameDOTname as str_nameDOTname,
 	Then as Then,
-	个 as 个,
+)
+
+from Z0Z_tools import importLogicalPath2Callable as importLogicalPath2Callable, importPathFilename2Callable as importPathFilename2Callable
+
+from astToolkit.transformationTools import (
+	inlineFunctionDef as inlineFunctionDef,
+	removeUnusedParameters as removeUnusedParameters,
+	unparseFindReplace as unparseFindReplace,
+	write_astModule as write_astModule,
 )
 
 from mapFolding.someAssemblyRequired._toolIfThis import IfThis as IfThis
 
-from mapFolding.someAssemblyRequired._toolboxContainers import (
+from mapFolding.someAssemblyRequired._toolkitContainers import (
 	DeReConstructField2ast as DeReConstructField2ast,
 	RecipeSynthesizeFlow as RecipeSynthesizeFlow,
 	ShatteredDataclass as ShatteredDataclass,

mapFolding/someAssemblyRequired/_toolIfThis.py

@@ -21,7 +21,7 @@ they implement a declarative approach to AST manipulation that separates node id
 
 from astToolkit import IfThis as astToolkit_IfThis
 from collections.abc import Callable
-from mapFolding.someAssemblyRequired import ast_Identifier, Be
+from mapFolding.someAssemblyRequired import ast_Identifier, Be, DOT
 from typing import TypeGuard
 import ast
 
@@ -39,15 +39,21 @@ class IfThis(astToolkit_IfThis):
 	@staticmethod
 	def isAttributeNamespace_IdentifierGreaterThan0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
 		return lambda node: (Be.Compare(node)
-					and IfThis.isAttributeNamespace_Identifier(namespace, identifier)(node.left)
+					and IfThis.isAttributeNamespace_Identifier(namespace, identifier)(DOT.left(node))
 					and Be.Gt(node.ops[0])
 					and IfThis.isConstant_value(0)(node.comparators[0]))
 	@staticmethod
 	def isIfAttributeNamespace_IdentifierGreaterThan0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.If] | bool]:
 		return lambda node: (Be.If(node)
-					and IfThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(node.test))
+					and IfThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(DOT.test(node)))
 
 	@staticmethod
 	def isWhileAttributeNamespace_IdentifierGreaterThan0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.While] | bool]:
 		return lambda node: (Be.While(node)
-					and IfThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(node.test))
+					and IfThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(DOT.test(node)))
+
+	@staticmethod
+	def isAttributeNamespace_IdentifierLessThanOrEqual0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
+		return lambda node: (Be.Compare(node)
+					and IfThis.isAttributeNamespace_Identifier(namespace, identifier)(DOT.left(node))
+					and Be.LtE(node.ops[0]))

mapFolding/someAssemblyRequired/{_toolboxContainers.py → _toolkitContainers.py}

@@ -18,11 +18,11 @@ The containers work in conjunction with transformation tools that manipulate the
 specific optimizations and transformations.
 """
 
-from astToolkit import IngredientsFunction as IngredientsFunction, IngredientsModule as IngredientsModule, LedgerOfImports as LedgerOfImports
 from collections.abc import Callable
+from astToolkit import ClassIsAndAttribute
 from copy import deepcopy
-from mapFolding.someAssemblyRequired import ast_Identifier, DOT, IfThis, Make, NodeTourist, parseLogicalPath2astModule, str_nameDOTname, Then
-from mapFolding.theSSOT import raiseIfNoneGitHubIssueNumber3, The
+from mapFolding.someAssemblyRequired import ast_Identifier, DOT, IfThis, Make, NodeTourist, parseLogicalPath2astModule, str_nameDOTname, Then, LedgerOfImports
+from mapFolding import raiseIfNoneGitHubIssueNumber3, The
 from pathlib import Path, PurePosixPath
 from typing import Any, cast
 import ast
@@ -158,10 +158,10 @@ class ShatteredDataclass:
 	countingVariableName: ast.Name
 	"""AST name node representing the counting variable identifier."""
 
-	field2AnnAssign: dict[ast_Identifier, ast.AnnAssign | ast.Assign] = dataclasses.field(default_factory=dict)
+	field2AnnAssign: dict[ast_Identifier, ast.AnnAssign | ast.Assign] = dataclasses.field(default_factory=lambda: dict[ast_Identifier, ast.AnnAssign | ast.Assign]())
 	"""Maps field names to their corresponding AST call expressions."""
 
-	Z0Z_field2AnnAssign: dict[ast_Identifier, tuple[ast.AnnAssign | ast.Assign, str]] = dataclasses.field(default_factory=dict)
+	Z0Z_field2AnnAssign: dict[ast_Identifier, tuple[ast.AnnAssign | ast.Assign, str]] = dataclasses.field(default_factory=lambda: dict[ast_Identifier, tuple[ast.AnnAssign | ast.Assign, str]]())
 
 	fragments4AssignmentOrParameters: ast.Tuple = dummyTuple
 	"""AST tuple used as target for assignment to capture returned fragments."""
@@ -169,22 +169,22 @@ class ShatteredDataclass:
 	imports: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
 	"""Import records for the dataclass and its constituent parts."""
 
-	list_argAnnotated4ArgumentsSpecification: list[ast.arg] = dataclasses.field(default_factory=list)
+	list_argAnnotated4ArgumentsSpecification: list[ast.arg] = dataclasses.field(default_factory=lambda: list[ast.arg]())
 	"""Function argument nodes with annotations for parameter specification."""
 
-	list_keyword_field__field4init: list[ast.keyword] = dataclasses.field(default_factory=list)
+	list_keyword_field__field4init: list[ast.keyword] = dataclasses.field(default_factory=lambda: list[ast.keyword]())
 	"""Keyword arguments for dataclass initialization with field=field format."""
 
-	listAnnotations: list[ast.expr] = dataclasses.field(default_factory=list)
+	listAnnotations: list[ast.expr] = dataclasses.field(default_factory=lambda: list[ast.expr]())
 	"""Type annotations for each dataclass field."""
 
-	listName4Parameters: list[ast.Name] = dataclasses.field(default_factory=list)
+	listName4Parameters: list[ast.Name] = dataclasses.field(default_factory=lambda: list[ast.Name]())
 	"""Name nodes for each dataclass field used as function parameters."""
 
-	listUnpack: list[ast.AnnAssign] = dataclasses.field(default_factory=list)
+	listUnpack: list[ast.AnnAssign] = dataclasses.field(default_factory=lambda: list[ast.AnnAssign]())
 	"""Annotated assignment statements to extract fields from dataclass."""
 
-	map_stateDOTfield2Name: dict[ast.AST, ast.Name] = dataclasses.field(default_factory=dict)
+	map_stateDOTfield2Name: dict[ast.AST, ast.Name] = dataclasses.field(default_factory=lambda: dict[ast.AST, ast.Name]())
 	"""Maps AST expressions to Name nodes for find-replace operations."""
 
 	repack: ast.Assign = dummyAssign
@@ -253,14 +253,12 @@ class DeReConstructField2ast:
 		self.ast_keyword_field__field = Make.keyword(self.name, self.astName)
 		self.ast_nameDOTname = Make.Attribute(Make.Name(dataclassesDOTdataclassInstance_Identifier), self.name)
 
-		findThis = IfThis.isAnnAssign_targetIs(IfThis.isName_Identifier(self.name))
-
-		sherpa = NodeTourist(
-			findThis=findThis
-			, doThat=Then.extractIt(DOT.annotation)
+		sherpa: ast.expr = NodeTourist( # type: ignore
+			findThis=ClassIsAndAttribute.targetIs(ast.AnnAssign, IfThis.isName_Identifier(self.name))
+			, doThat=Then.extractIt(DOT.annotation) # type: ignore
 			).captureLastMatch(dataclassClassDef)
 
-		if sherpa is None: raise raiseIfNoneGitHubIssueNumber3
+		if sherpa is None: raise raiseIfNoneGitHubIssueNumber3 # type: ignore
 		else: self.astAnnotation = sherpa
 
 		self.ast_argAnnotated = Make.arg(self.name, self.astAnnotation)

mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py

@@ -1,4 +1,5 @@
-from mapFolding import getPathFilenameFoldsTotal, raiseIfNoneGitHubIssueNumber3, The
+from astToolkit import ClassIsAndAttribute
+from mapFolding import getPathFilenameFoldsTotal, raiseIfNoneGitHubIssueNumber3, The, MapFoldingState
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
 	Be,
@@ -12,12 +13,11 @@ from mapFolding.someAssemblyRequired import (
 	NodeTourist,
 	str_nameDOTname,
 	Then,
+	write_astModule,
 )
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2Numba
-from mapFolding.someAssemblyRequired.toolboxNumba import parametersNumbaLight, SpicesJobNumba, decorateCallableWithNumba
-from mapFolding.someAssemblyRequired.transformationTools import write_astModule
+from mapFolding.someAssemblyRequired.toolkitNumba import parametersNumbaLight, SpicesJobNumba, decorateCallableWithNumba
 from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
-from mapFolding.dataBaskets import MapFoldingState
 from pathlib import PurePosixPath
 from typing import cast, NamedTuple
 from Z0Z_tools import autoDecodingRLE
@@ -77,7 +77,7 @@ if __name__ == '__main__':
 	ast_argNumbaProgress = ast.arg(arg=spices.numbaProgressBarIdentifier, annotation=ast.Name(id=numba_progressPythonClass, ctx=ast.Load()))
 	ingredientsFunction.astFunctionDef.args.args.append(ast_argNumbaProgress)
 
-	findThis = IfThis.isAugAssignAndTargetIs(IfThis.isName_Identifier(job.shatteredDataclass.countingVariableName.id))
+	findThis = ClassIsAndAttribute.targetIs(ast.AugAssign, IfThis.isName_Identifier(job.shatteredDataclass.countingVariableName.id)) # type: ignore
 	doThat = Then.replaceWith(Make.Expr(Make.Call(Make.Attribute(Make.Name(spices.numbaProgressBarIdentifier),'update'),[Make.Constant(1)])))
 	countWithProgressBar = NodeChanger(findThis, doThat)
 	countWithProgressBar.visit(ingredientsFunction.astFunctionDef)
@@ -161,10 +161,11 @@ def makeJobNumba(job: RecipeJobTheorem2Numba, spices: SpicesJobNumba) -> None:
 	ingredientsCount: IngredientsFunction = IngredientsFunction(astFunctionDef, LedgerOfImports())
 
 	# Remove `foldGroups` and any other unused statements, so you can dynamically determine which variables are not used
-	findThis = IfThis.isAssignAndTargets0Is(IfThis.isSubscript_Identifier('foldGroups'))
+	findThis = ClassIsAndAttribute.targetsIs(ast.Assign, lambda list_expr: any([IfThis.isSubscript_Identifier('foldGroups')(node) for node in list_expr ]))
+	# findThis = IfThis.isAssignAndTargets0Is(IfThis.isSubscript_Identifier('foldGroups'))
 	doThat = Then.removeIt
 	remove_foldGroups = NodeChanger(findThis, doThat)
-	remove_foldGroups.visit(ingredientsCount.astFunctionDef)
+	# remove_foldGroups.visit(ingredientsCount.astFunctionDef)
 
 	# replace identifiers with static values with their values, so you can dynamically determine which variables are not used
 	list_IdentifiersStaticValues = list_IdentifiersStaticValuesHARDCODED
@@ -260,7 +261,7 @@ if __name__ == '__main__':
 	"""
 
 if __name__ == '__main__':
-	mapShape = (1,46)
+	mapShape = (2,4)
 	state = MapFoldingState(mapShape)
 	state = initializeGroupsOfFolds(state)
 	# foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal

mapFolding/someAssemblyRequired/synthesizeNumbaJob.py

@@ -18,6 +18,7 @@ This creates extremely fast, specialized implementations that can be run directl
 as Python scripts or further compiled into standalone executables.
 """
 
+from astToolkit import ClassIsAndAttribute
 from mapFolding import getPathFilenameFoldsTotal, raiseIfNoneGitHubIssueNumber3, The
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
@@ -32,10 +33,11 @@ from mapFolding.someAssemblyRequired import (
 	NodeTourist,
 	str_nameDOTname,
 	Then,
+	write_astModule,
 )
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJob
-from mapFolding.someAssemblyRequired.toolboxNumba import parametersNumbaLight, SpicesJobNumba, decorateCallableWithNumba
-from mapFolding.someAssemblyRequired.transformationTools import dictionaryEstimates, write_astModule, makeInitializedComputationState
+from mapFolding.someAssemblyRequired.toolkitNumba import parametersNumbaLight, SpicesJobNumba, decorateCallableWithNumba
+from mapFolding.someAssemblyRequired.transformationTools import dictionaryEstimates, makeInitializedComputationState
 from pathlib import PurePosixPath
 from typing import cast, NamedTuple
 from Z0Z_tools import autoDecodingRLE
@@ -95,7 +97,7 @@ if __name__ == '__main__':
 	ast_argNumbaProgress = ast.arg(arg=spices.numbaProgressBarIdentifier, annotation=ast.Name(id=numba_progressPythonClass, ctx=ast.Load()))
 	ingredientsFunction.astFunctionDef.args.args.append(ast_argNumbaProgress)
 
-	findThis = IfThis.isAugAssignAndTargetIs(IfThis.isName_Identifier(job.shatteredDataclass.countingVariableName.id))
+	findThis = ClassIsAndAttribute.targetIs(ast.AugAssign, IfThis.isName_Identifier(job.shatteredDataclass.countingVariableName.id)) # type: ignore
 	doThat = Then.replaceWith(Make.Expr(Make.Call(Make.Attribute(Make.Name(spices.numbaProgressBarIdentifier),'update'),[Make.Constant(1)])))
 	countWithProgressBar = NodeChanger(findThis, doThat)
 	countWithProgressBar.visit(ingredientsFunction.astFunctionDef)

mapFolding/someAssemblyRequired/{toolboxNumba.py → toolkitNumba.py}

@@ -17,8 +17,8 @@ performance improvements while preserving code semantics and correctness.
 
 from collections.abc import Callable, Sequence
 from mapFolding import NotRequired, TypedDict
-from mapFolding.someAssemblyRequired import ast_Identifier, IngredientsFunction, Make, RecipeSynthesizeFlow, str_nameDOTname
-from mapFolding.someAssemblyRequired.transformationTools import makeNewFlow, write_astModule
+from mapFolding.someAssemblyRequired import ast_Identifier, IngredientsFunction, Make, RecipeSynthesizeFlow, str_nameDOTname, write_astModule
+from mapFolding.someAssemblyRequired.transformationTools import makeNewFlow
 from numba.core.compiler import CompilerBase as numbaCompilerBase
 from typing import Any, cast, Final
 import ast