mapFolding 0.9.3__tar.gz → 0.9.4__tar.gz

{mapfolding-0.9.3 → mapfolding-0.9.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.9.3
+Version: 0.9.4
 Summary: Map folding algorithm with code transformation framework for optimizing numerical computations
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -32,6 +32,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: autoflake
+Requires-Dist: cytoolz
 Requires-Dist: more_itertools
 Requires-Dist: numba_progress
 Requires-Dist: numba

{mapfolding-0.9.3 → mapfolding-0.9.4}/mapFolding/Z0Z_flowControl.py

@@ -22,12 +22,6 @@ def countFolds(listDimensions: Sequence[int] | None = None
 				, oeis_n: int | None = None
 				, flow: str | None = None
 				) -> int:
-	"""
-	To select the execution path, I need at least:
-		- mapShape
-		- task division instructions
-		- memorialization instructions
-	"""
 
 	# mapShape =====================================================================
 
@@ -73,14 +67,38 @@ def countFolds(listDimensions: Sequence[int] | None = None
 
 	# Flow control until I can figure out a good way ===============================
 
-	if flow == 'theDaoOfMapFolding':
+	if flow == 'daoOfMapFolding':
 		from mapFolding.dataBaskets import MapFoldingState
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-		from mapFolding.theDaoOfMapFolding import doTheNeedful
+		from mapFolding.daoOfMapFolding import doTheNeedful
 		mapFoldingState = doTheNeedful(mapFoldingState)
 		foldsTotal = mapFoldingState.foldsTotal
 
+	elif flow == 'theorem2' and any((dimension > 2 for dimension in mapShape)):
+		from mapFolding.dataBaskets import MapFoldingState
+		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+		from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
+		mapFoldingState = initializeGroupsOfFolds(mapFoldingState)
+
+		from mapFolding.syntheticModules.theorem2 import count
+		mapFoldingState = count(mapFoldingState)
+
+		foldsTotal = mapFoldingState.foldsTotal
+
+	elif (flow == 'theorem2Numba' or taskDivisions == 0) and any((dimension > 2 for dimension in mapShape)):
+		from mapFolding.dataBaskets import MapFoldingState
+		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+		from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
+		mapFoldingState = initializeGroupsOfFolds(mapFoldingState)
+
+		from mapFolding.syntheticModules.dataPacking import doTheNeedful
+		mapFoldingState = doTheNeedful(mapFoldingState)
+
+		foldsTotal = mapFoldingState.foldsTotal
+
 	# NOTE treat this as a default?
 	# flow based on `The` and `ComputationState` ====================================
 

mapfolding-0.9.4/mapFolding/someAssemblyRequired/Z0Z_makeSomeModules.py

@@ -0,0 +1,226 @@
+from mapFolding import raiseIfNoneGitHubIssueNumber3, The
+from mapFolding.someAssemblyRequired import (
+	ast_Identifier,
+	astModuleToIngredientsFunction,
+	be,
+	DOT,
+	extractFunctionDef,
+	grab,
+	ifThis,
+	IngredientsFunction,
+	IngredientsModule,
+	LedgerOfImports,
+	Make,
+	NodeChanger,
+	NodeTourist,
+	parseLogicalPath2astModule,
+	parsePathFilename2astModule,
+	Then,
+	str_nameDOTname,
+)
+from mapFolding.someAssemblyRequired.toolboxNumba import decorateCallableWithNumba, parametersNumbaLight
+from mapFolding.someAssemblyRequired.transformationTools import (
+	inlineFunctionDef,
+	removeDataclassFromFunction,
+	removeUnusedParameters,
+	shatter_dataclassesDOTdataclass,
+	unpackDataclassCallFunctionRepackDataclass,
+	write_astModule,
+	)
+from pathlib import PurePath
+import ast
+
+algorithmSourceModuleHARDCODED = 'daoOfMapFolding'
+sourceCallableIdentifierHARDCODED = 'count'
+logicalPathInfixHARDCODED: ast_Identifier = 'syntheticModules'
+theCountingIdentifierHARDCODED: ast_Identifier = 'groupsOfFolds'
+
+def makeInitializeGroupsOfFolds():
+	callableIdentifierHARDCODED = 'initializeGroupsOfFolds'
+	moduleIdentifierHARDCODED: ast_Identifier = 'initializeCount'
+
+	algorithmSourceModule = algorithmSourceModuleHARDCODED
+	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
+	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
+
+	callableIdentifier = callableIdentifierHARDCODED
+	logicalPathInfix = logicalPathInfixHARDCODED
+	moduleIdentifier = moduleIdentifierHARDCODED
+
+	astModule = parseLogicalPath2astModule(logicalPathSourceModule)
+	countInitializeIngredients = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule)
+		, LedgerOfImports(astModule))
+
+	countInitializeIngredients.astFunctionDef.name = callableIdentifier
+
+	dataclassInstanceIdentifier = NodeTourist(be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countInitializeIngredients.astFunctionDef)
+	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
+	theCountingIdentifier = theCountingIdentifierHARDCODED
+
+	findThis = ifThis.isWhileAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	doThat = grab.testAttribute(grab.andDoAllOf([
+		grab.opsAttribute(Then.replaceWith([ast.Eq()])), # type: ignore
+		grab.leftAttribute(grab.attrAttribute(Then.replaceWith(theCountingIdentifier))) # type: ignore
+	]))
+	NodeChanger(findThis, doThat).visit(countInitializeIngredients.astFunctionDef.body[0])
+
+	initializationModule = IngredientsModule(countInitializeIngredients)
+
+	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
+
+	write_astModule(initializationModule, pathFilename, The.packageName)
+
+def makeTheorem2():
+	moduleIdentifierHARDCODED: ast_Identifier = 'theorem2'
+
+	algorithmSourceModule = algorithmSourceModuleHARDCODED
+	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
+	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
+
+	logicalPathInfix = logicalPathInfixHARDCODED
+	moduleIdentifier = moduleIdentifierHARDCODED
+
+	astModule = parseLogicalPath2astModule(logicalPathSourceModule)
+	countTheorem2 = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule)
+		, LedgerOfImports(astModule))
+
+	dataclassInstanceIdentifier = NodeTourist(be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countTheorem2.astFunctionDef)
+	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
+
+	findThis = ifThis.isWhileAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	doThat = grab.testAttribute(grab.comparatorsAttribute(Then.replaceWith([Make.Constant(4)]))) # type: ignore
+	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
+
+	findThis = ifThis.isIfAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	doThat = Then.extractIt(DOT.body)
+	insertLeaf = NodeTourist(findThis, doThat).captureLastMatch(countTheorem2.astFunctionDef)
+	findThis = ifThis.isIfAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	doThat = Then.replaceWith(insertLeaf)
+	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
+
+	findThis = ifThis.isAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	doThat = Then.removeIt
+	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
+
+	findThis = ifThis.isAttributeNamespace_IdentifierLessThanOrEqual(dataclassInstanceIdentifier, 'leaf1ndex')
+	doThat = Then.removeIt
+	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
+
+	theCountingIdentifier = theCountingIdentifierHARDCODED
+	doubleTheCount = Make.AugAssign(Make.Attribute(ast.Name(dataclassInstanceIdentifier), theCountingIdentifier), ast.Mult(), Make.Constant(2))
+	findThis = be.Return
+	doThat = Then.insertThisAbove([doubleTheCount])
+	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
+
+	moduleTheorem2 = IngredientsModule(countTheorem2)
+
+	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
+
+	write_astModule(moduleTheorem2, pathFilename, The.packageName)
+
+	return pathFilename
+
+def numbaOnTheorem2(pathFilenameSource: PurePath):
+	logicalPathInfix = logicalPathInfixHARDCODED
+	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
+	countNumbaTheorem2 = astModuleToIngredientsFunction(parsePathFilename2astModule(pathFilenameSource), sourceCallableIdentifier)
+	dataclassName: ast.expr | None = NodeTourist(be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(countNumbaTheorem2.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 countNumbaTheorem2.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(countNumbaTheorem2.astFunctionDef)
+	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
+	shatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclass_Identifier, dataclassInstanceIdentifier)
+
+	countNumbaTheorem2.imports.update(shatteredDataclass.imports)
+	countNumbaTheorem2 = removeDataclassFromFunction(countNumbaTheorem2, shatteredDataclass)
+
+	countNumbaTheorem2 = removeUnusedParameters(countNumbaTheorem2)
+
+	countNumbaTheorem2 = decorateCallableWithNumba(countNumbaTheorem2, parametersNumbaLight)
+
+	moduleNumbaTheorem2 = IngredientsModule(countNumbaTheorem2)
+	moduleNumbaTheorem2.removeImportFromModule('numpy')
+
+	pathFilename = pathFilenameSource.with_stem(pathFilenameSource.stem + 'Numba')
+
+	write_astModule(moduleNumbaTheorem2, pathFilename, The.packageName)
+
+	logicalPath: list[str] = []
+	if The.packageName:
+		logicalPath.append(The.packageName)
+	if logicalPathInfix:
+		logicalPath.append(logicalPathInfix)
+	logicalPath.append(pathFilename.stem)
+	moduleWithLogicalPath: str_nameDOTname = '.'.join(logicalPath)
+
+	astImportFrom: ast.ImportFrom = Make.ImportFrom(moduleWithLogicalPath, list_astAlias=[Make.alias(countNumbaTheorem2.astFunctionDef.name)])
+
+	return astImportFrom
+
+def makeUnRePackDataclass(astImportFrom: ast.ImportFrom):
+	moduleIdentifierHARDCODED: ast_Identifier = 'dataPacking'
+
+	algorithmSourceModule = algorithmSourceModuleHARDCODED
+	sourceCallableIdentifier = The.sourceCallableDispatcher
+	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
+
+	callableIdentifier = sourceCallableIdentifier
+	logicalPathInfix = logicalPathInfixHARDCODED
+	moduleIdentifier = moduleIdentifierHARDCODED
+
+	doTheNeedful: IngredientsFunction = astModuleToIngredientsFunction(parseLogicalPath2astModule(logicalPathSourceModule), sourceCallableIdentifier)
+	dataclassName: ast.expr | None = NodeTourist(be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(doTheNeedful.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 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(doTheNeedful.astFunctionDef)
+	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
+	shatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclass_Identifier, dataclassInstanceIdentifier)
+
+	doTheNeedful.imports.update(shatteredDataclass.imports)
+	doTheNeedful.imports.addAst(astImportFrom)
+	targetCallableIdentifier = astImportFrom.names[0].name
+	doTheNeedful = unpackDataclassCallFunctionRepackDataclass(doTheNeedful, targetCallableIdentifier, shatteredDataclass)
+	targetFunctionDef = extractFunctionDef(parseLogicalPath2astModule(astImportFrom.module), targetCallableIdentifier) # type: ignore
+	if targetFunctionDef is None: raise raiseIfNoneGitHubIssueNumber3
+	astTuple: ast.Tuple | None = NodeTourist(be.Return, Then.extractIt(DOT.value)).captureLastMatch(targetFunctionDef)
+	if astTuple is None: raise raiseIfNoneGitHubIssueNumber3
+	astTuple.ctx = ast.Store()
+
+	findThis = ifThis.isAssignAndValueIs(ifThis.isCall_Identifier(targetCallableIdentifier))
+	doThat = Then.replaceWith(Make.Assign(listTargets=[astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
+	NodeChanger(findThis, doThat).visit(doTheNeedful.astFunctionDef)
+
+	moduleDoTheNeedful = IngredientsModule(doTheNeedful)
+	moduleDoTheNeedful.removeImportFromModule('numpy')
+
+	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
+
+	write_astModule(moduleDoTheNeedful, pathFilename, The.packageName)
+
+if __name__ == '__main__':
+	makeInitializeGroupsOfFolds()
+	pathFilename = makeTheorem2()
+	astImportFrom = numbaOnTheorem2(pathFilename)
+	makeUnRePackDataclass(astImportFrom)

{mapfolding-0.9.3 → mapfolding-0.9.4}/mapFolding/someAssemblyRequired/__init__.py

@@ -50,14 +50,18 @@ to verify correctness at each transformation stage through the integrated test s
 from mapFolding.someAssemblyRequired._theTypes import (
 	ast_expr_Slice as ast_expr_Slice,
 	ast_Identifier as ast_Identifier,
+	astClassHasDOTbody as astClassHasDOTbody,
+	astClassHasDOTbody_expr as astClassHasDOTbody_expr,
+	astClassHasDOTbodyList_stmt as astClassHasDOTbodyList_stmt,
 	astClassHasDOTnameNotName as astClassHasDOTnameNotName,
+	astClassHasDOTnameNotNameAlways as astClassHasDOTnameNotNameAlways,
+	astClassHasDOTnameNotNameOptionally as astClassHasDOTnameNotNameOptionally,
 	astClassHasDOTtarget as astClassHasDOTtarget,
 	astClassHasDOTtarget_expr as astClassHasDOTtarget_expr,
 	astClassHasDOTtargetAttributeNameSubscript as astClassHasDOTtargetAttributeNameSubscript,
 	astClassHasDOTvalue as astClassHasDOTvalue,
 	astClassHasDOTvalue_expr as astClassHasDOTvalue_expr,
 	astClassHasDOTvalue_exprNone as astClassHasDOTvalue_exprNone,
-	astClassOptionallyHasDOTnameNotName as astClassOptionallyHasDOTnameNotName,
 	ImaCallToName as ImaCallToName,
 	intORlist_ast_type_paramORstr_orNone as intORlist_ast_type_paramORstr_orNone,
 	intORstr_orNone as intORstr_orNone,
@@ -87,3 +91,9 @@ from mapFolding.someAssemblyRequired._toolboxContainers import (
 	RecipeSynthesizeFlow as RecipeSynthesizeFlow,
 	ShatteredDataclass as ShatteredDataclass,
 )
+
+from mapFolding.someAssemblyRequired._toolboxAST import (
+	astModuleToIngredientsFunction as astModuleToIngredientsFunction,
+	extractClassDef as extractClassDef,
+	extractFunctionDef as extractFunctionDef,
+	)

{mapfolding-0.9.3 → mapfolding-0.9.4}/mapFolding/someAssemblyRequired/_theTypes.py

@@ -6,11 +6,13 @@ stuPyd: typing_TypeAlias = str
 if TYPE_CHECKING:
 	"""	3.12 new: ast.ParamSpec, ast.type_param, ast.TypeAlias, ast.TypeVar, ast.TypeVarTuple
 		3.11 new: ast.TryStar"""
-	astClassHasDOTnameNotName: typing_TypeAlias = ast.alias | ast.AsyncFunctionDef | ast.ClassDef | ast.FunctionDef | ast.ParamSpec | ast.TypeVar | ast.TypeVarTuple
+	astClassHasDOTbodyList_stmt: typing_TypeAlias = ast.AsyncFor | ast.AsyncWith | ast.ClassDef | ast.ExceptHandler | ast.For | ast.FunctionDef | ast.If | ast.Interactive | ast.match_case | ast.Module | ast.Try | ast.TryStar | ast.While | ast.With
+	astClassHasDOTnameNotNameAlways: typing_TypeAlias = ast.alias | ast.AsyncFunctionDef | ast.ClassDef | ast.FunctionDef | ast.ParamSpec | ast.TypeVar | ast.TypeVarTuple
 	astClassHasDOTvalue_expr: typing_TypeAlias = ast.Assign | ast.Attribute | ast.AugAssign | ast.Await | ast.DictComp | ast.Expr | ast.FormattedValue | ast.keyword | ast.MatchValue | ast.NamedExpr | ast.Starred | ast.Subscript | ast.TypeAlias | ast.YieldFrom
 
 else:
-	astClassHasDOTnameNotName = stuPyd
+	astClassHasDOTbodyList_stmt = stuPyd
+	astClassHasDOTnameNotNameAlways = stuPyd
 	astClassHasDOTvalue_expr = stuPyd
 
 class ImaCallToName(ast.Call):
@@ -18,12 +20,16 @@ class ImaCallToName(ast.Call):
 	# assert isinstance(ast.Call.func, ast.Name), "brinkmanship"
 	# func: ast.Name
 
+astClassHasDOTbody_expr: typing_TypeAlias = ast.Expression | ast.IfExp | ast.Lambda
+astClassHasDOTbody: typing_TypeAlias = astClassHasDOTbody_expr | astClassHasDOTbodyList_stmt
+
+astClassHasDOTnameNotNameOptionally: typing_TypeAlias = ast.ExceptHandler | ast.MatchAs | ast.MatchStar
+astClassHasDOTnameNotName: typing_TypeAlias = astClassHasDOTnameNotNameAlways | astClassHasDOTnameNotNameOptionally
+
 astClassHasDOTtargetAttributeNameSubscript: typing_TypeAlias = ast.AnnAssign | ast.AugAssign
 astClassHasDOTtarget_expr: typing_TypeAlias = ast.AsyncFor | ast.comprehension | ast.For
 astClassHasDOTtarget: typing_TypeAlias = ast.NamedExpr | astClassHasDOTtarget_expr | astClassHasDOTtargetAttributeNameSubscript
 
-astClassOptionallyHasDOTnameNotName: typing_TypeAlias = ast.ExceptHandler | ast.MatchAs | ast.MatchStar
-
 astClassHasDOTvalue_exprNone: typing_TypeAlias = ast.AnnAssign | ast.Return | ast.Yield
 astClassHasDOTvalue: typing_TypeAlias = ast.Constant | ast.MatchSingleton | astClassHasDOTvalue_expr | astClassHasDOTvalue_exprNone
 

{mapfolding-0.9.3 → mapfolding-0.9.4}/mapFolding/someAssemblyRequired/_tool_Make.py

@@ -73,6 +73,10 @@ class Make:
 			buffaloBuffalo = addDOTattribute(buffaloBuffalo, identifier, context, **keywordArguments)
 		return buffaloBuffalo
 
+	@staticmethod
+	def AugAssign(target: ast.Attribute | ast.Name | ast.Subscript, operator: ast.operator, value: ast.expr, **keywordArguments: int) -> ast.AugAssign:
+		return ast.AugAssign(target, operator, value, **keywordArguments)
+
 	@staticmethod
 	def Call(callee: ast.expr, listArguments: Sequence[ast.expr] | None = None, list_astKeywords: Sequence[ast.keyword] | None = None) -> ast.Call:
 		return ast.Call(func=callee, args=list(listArguments) if listArguments else [], keywords=list(list_astKeywords) if list_astKeywords else [])
@@ -124,3 +128,7 @@ class Make:
 	@staticmethod
 	def Tuple(elements: Sequence[ast.expr] = [], context: ast.expr_context = ast.Load(), **keywordArguments: int) -> ast.Tuple:
 		return ast.Tuple(list(elements), context, **keywordArguments)
+
+	@staticmethod
+	def While(test: ast.expr, doThis: list[ast.stmt], orElse: list[ast.stmt] = [], **keywordArguments: int) -> ast.While:
+		return ast.While(test, doThis, orElse, **keywordArguments)

{mapfolding-0.9.3 → mapfolding-0.9.4}/mapFolding/someAssemblyRequired/_tool_Then.py

@@ -16,7 +16,7 @@ once they have been identified using predicate functions from ifThis.
 
 from collections.abc import Callable, Sequence
 from mapFolding.someAssemblyRequired import ast_Identifier, astClassHasDOTvalue, ImaCallToName, NodeORattribute
-from typing import Any
+from typing import Any, overload
 import ast
 
 class grab:
@@ -32,6 +32,14 @@ class grab:
 	specific attribute of that node, and returns the modified node. This enables fine-grained
 	control when transforming AST structures.
 	"""
+	@staticmethod
+	def andDoAllOf(listOfActions: list[Callable[[NodeORattribute], NodeORattribute]]) -> Callable[[NodeORattribute], NodeORattribute]:
+		def workhorse(node: NodeORattribute) -> NodeORattribute:
+			for action in listOfActions:
+				node = action(node)
+			return node
+		return workhorse
+
 	@staticmethod
 	def argAttribute(action: Callable[[ast_Identifier | None], ast_Identifier]) -> Callable[[ast.arg | ast.keyword], ast.arg | ast.keyword]:
 		def workhorse(node: ast.arg | ast.keyword) -> ast.arg | ast.keyword:
@@ -39,6 +47,20 @@ class grab:
 			return node
 		return workhorse
 
+	@staticmethod
+	def attrAttribute(action: Callable[[ast_Identifier], ast_Identifier]) -> Callable[[ast.Attribute], ast.Attribute]:
+		def workhorse(node: ast.Attribute) -> ast.Attribute:
+			node.attr = action(node.attr)
+			return node
+		return workhorse
+
+	@staticmethod
+	def comparatorsAttribute(action: Callable[[list[ast.expr]], list[ast.expr]]) -> Callable[[ast.Compare], ast.Compare]:
+		def workhorse(node: ast.Compare) -> ast.Compare:
+			node.comparators = action(node.comparators)
+			return node
+		return workhorse
+
 	@staticmethod
 	def funcAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[ast.Call], ast.Call]:
 		def workhorse(node: ast.Call) -> ast.Call:
@@ -60,6 +82,27 @@ class grab:
 			return node
 		return workhorse
 
+	@staticmethod
+	def leftAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[ast.BinOp | ast.Compare], ast.BinOp | ast.Compare]:
+		def workhorse(node: ast.BinOp | ast.Compare) -> ast.BinOp | ast.Compare:
+			node.left = action(node.left)
+			return node
+		return workhorse
+
+	@staticmethod
+	def opsAttribute(action: Callable[[list[ast.cmpop]], list[ast.cmpop]]) -> Callable[[ast.Compare], ast.Compare]:
+		def workhorse(node: ast.Compare) -> ast.Compare:
+			node.ops = action(node.ops)
+			return node
+		return workhorse
+
+	@staticmethod
+	def testAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[ast.Assert | ast.If | ast.IfExp | ast.While], ast.Assert | ast.If | ast.IfExp | ast.While]:
+		def workhorse(node: ast.Assert | ast.If | ast.IfExp | ast.While) -> ast.Assert | ast.If | ast.IfExp | ast.While:
+			node.test = action(node.test)
+			return node
+		return workhorse
+
 	@staticmethod
 	def valueAttribute(action: Callable[[Any], Any]) -> Callable[[astClassHasDOTvalue], astClassHasDOTvalue]:
 		def workhorse(node: astClassHasDOTvalue) -> astClassHasDOTvalue:

mapfolding-0.9.4/mapFolding/someAssemblyRequired/_toolboxAST.py

@@ -0,0 +1,57 @@
+from mapFolding.someAssemblyRequired import ast_Identifier, ifThis, IngredientsFunction, LedgerOfImports, NodeTourist, Then
+from mapFolding.theSSOT import raiseIfNoneGitHubIssueNumber3
+import ast
+
+def astModuleToIngredientsFunction(astModule: ast.AST, identifierFunctionDef: ast_Identifier) -> IngredientsFunction:
+	"""
+	Extract a function definition from an AST module and create an `IngredientsFunction`.
+
+	This function finds a function definition with the specified identifier in the given AST module, extracts it, and
+	stores all module imports in the `LedgerOfImports`.
+
+	Parameters:
+		astModule: The AST module containing the function definition.
+		identifierFunctionDef: The name of the function to extract.
+
+	Returns:
+		ingredientsFunction: `IngredientsFunction` object containing the `ast.FunctionDef` and _all_ imports from the
+		source module.
+
+	Raises:
+		raiseIfNoneGitHubIssueNumber3: If the function definition is not found.
+	"""
+	astFunctionDef = extractFunctionDef(astModule, identifierFunctionDef)
+	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
+	return IngredientsFunction(astFunctionDef, LedgerOfImports(astModule))
+
+def extractClassDef(module: ast.AST, identifier: ast_Identifier) -> ast.ClassDef | None:
+	"""
+	Extract a class definition with a specific name from an AST module.
+
+	This function searches through an AST module for a class definition that matches the provided identifier and returns
+	it if found.
+
+	Parameters:
+		module: The AST module to search within.
+		identifier: The name of the class to find.
+
+	Returns:
+		astClassDef|None: The matching class definition AST node, or `None` if not found.
+	"""
+	return NodeTourist(ifThis.isClassDef_Identifier(identifier), Then.extractIt).captureLastMatch(module)
+
+def extractFunctionDef(module: ast.AST, identifier: ast_Identifier) -> ast.FunctionDef | None:
+	"""
+	Extract a function definition with a specific name from an AST module.
+
+	This function searches through an AST module for a function definition that matches the provided identifier and
+	returns it if found.
+
+	Parameters:
+		module: The AST module to search within.
+		identifier: The name of the function to find.
+
+	Returns:
+		astFunctionDef|None: The matching function definition AST node, or `None` if not found.
+	"""
+	return NodeTourist(ifThis.isFunctionDef_Identifier(identifier), Then.extractIt).captureLastMatch(module)