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

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/someAssemblyRequired/__init__.py

@@ -22,7 +22,7 @@ functional implementations into highly-optimized variants with verified correctn
    - Recipe configuration for generating optimized code (RecipeSynthesizeFlow)
    - Dataclass decomposition for compatibility (ShatteredDataclass)
 
-3. **Optimization Pipelines**
+3. **Optimization assembly lines**
    - General-purpose Numba acceleration (makeNumbaFlow)
    - Job-specific optimization for concrete parameters (makeJobNumba)
    - Specialized component transformation (decorateCallableWithNumba)
@@ -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/someAssemblyRequired/_theTypes.py

@@ -6,24 +6,30 @@ 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):
 	func: ast.Name # pyright: ignore[reportIncompatibleVariableOverride]
-	# assert isinstance(ast.Call.func, ast.Name), "brinksmanship"
+	# 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/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/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/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)

mapFolding/someAssemblyRequired/_toolboxAntecedents.py

@@ -1,36 +1,39 @@
 """
 AST Node Predicate and Access Utilities for Pattern Matching and Traversal
 
-This module provides utilities for accessing and matching AST nodes in a consistent way.
-It contains three primary classes:
+This module provides utilities for accessing and matching AST nodes in a consistent way. It contains three primary
+classes:
 
-1. DOT: Provides consistent accessor methods for AST node attributes across different
-   node types, simplifying the access to node properties.
+1. DOT: Provides consistent accessor methods for AST node attributes across different node types, simplifying the access
+	to node properties.
 
-2. be: Offers type-guard functions that verify AST node types, enabling safe type
-   narrowing for static type checking and improving code safety.
+2. be: Offers type-guard functions that verify AST node types, enabling safe type narrowing for static type checking and
+	improving code safety.
 
-3. ifThis: Contains predicate functions for matching AST nodes based on various criteria,
-   enabling precise targeting of nodes for analysis or transformation.
+3. ifThis: Contains predicate functions for matching AST nodes based on various criteria, enabling precise targeting of
+	nodes for analysis or transformation.
 
-These utilities form the foundation of the pattern-matching component in the AST
-manipulation framework, working in conjunction with the NodeChanger and NodeTourist
-classes to enable precise and targeted code transformations. Together, they implement
-a declarative approach to AST manipulation that separates node identification (ifThis),
-type verification (be), and data access (DOT).
+These utilities form the foundation of the pattern-matching component in the AST manipulation framework, working in
+conjunction with the NodeChanger and NodeTourist classes to enable precise and targeted code transformations. Together,
+they implement a declarative approach to AST manipulation that separates node identification (ifThis), type verification
+(be), and data access (DOT).
 """
 
 from collections.abc import Callable
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
+	astClassHasDOTbody,
+	astClassHasDOTbody_expr,
+	astClassHasDOTbodyList_stmt,
 	astClassHasDOTnameNotName,
+	astClassHasDOTnameNotNameAlways,
+	astClassHasDOTnameNotNameOptionally,
+	astClassHasDOTtarget_expr,
 	astClassHasDOTtarget,
 	astClassHasDOTtargetAttributeNameSubscript,
-	astClassHasDOTtarget_expr,
-	astClassHasDOTvalue,
 	astClassHasDOTvalue_expr,
-	astClassOptionallyHasDOTnameNotName,
 	astClassHasDOTvalue_exprNone,
+	astClassHasDOTvalue,
 	ImaCallToName,
 )
 from typing import Any, overload, TypeGuard
@@ -72,6 +75,16 @@ class DOT:
 	def attr(node: ast.Attribute) -> ast_Identifier:
 		return node.attr
 
+	@staticmethod
+	@overload
+	def body(node: astClassHasDOTbodyList_stmt) -> list[ast.stmt]:...
+	@staticmethod
+	@overload
+	def body(node: astClassHasDOTbody_expr) -> ast.expr:...
+	@staticmethod
+	def body(node: astClassHasDOTbody) -> ast.expr | list[ast.stmt]:
+		return node.body
+
 	@staticmethod
 	@overload
 	def func(node: ImaCallToName) -> ast.Name:...
@@ -88,12 +101,12 @@ class DOT:
 
 	@staticmethod
 	@overload
-	def name(node: astClassHasDOTnameNotName) -> ast_Identifier:...
+	def name(node: astClassHasDOTnameNotNameAlways) -> ast_Identifier:...
 	@staticmethod
 	@overload
-	def name(node: astClassOptionallyHasDOTnameNotName) -> ast_Identifier | None:...
+	def name(node: astClassHasDOTnameNotNameOptionally) -> ast_Identifier | None:...
 	@staticmethod
-	def name(node: astClassHasDOTnameNotName | astClassOptionallyHasDOTnameNotName) -> ast_Identifier | None:
+	def name(node: astClassHasDOTnameNotName) -> ast_Identifier | None:
 		return node.name
 
 	@staticmethod
@@ -129,18 +142,16 @@ class be:
 	"""
 	Provide type-guard functions for safely verifying AST node types during manipulation.
 
-	The be class contains static methods that perform runtime type verification of AST nodes,
-	returning TypeGuard results that enable static type checkers to narrow node types in
-	conditional branches. These type-guards:
+	The be class contains static methods that perform runtime type verification of AST nodes, returning TypeGuard
+	results that enable static type checkers to narrow node types in conditional branches. These type-guards:
 
-	1. Improve code safety by preventing operations on incompatible node types
-	2. Enable IDE tooling to provide better autocompletion and error detection
-	3. Document expected node types in a way that's enforced by the type system
-	4. Support pattern-matching workflows where node types must be verified before access
+	1. Improve code safety by preventing operations on incompatible node types.
+	2. Enable IDE tooling to provide better autocompletion and error detection.
+	3. Document expected node types in a way that's enforced by the type system.
+	4. Support pattern-matching workflows where node types must be verified before access.
 
-	When used with conditional statements, these type-guards allow for precise,
-	type-safe manipulation of AST nodes while maintaining full static type checking
-	capabilities, even in complex transformation scenarios.
+	When used with conditional statements, these type-guards allow for precise, type-safe manipulation of AST nodes
+	while maintaining full static type checking capabilities, even in complex transformation scenarios.
 	"""
 	@staticmethod
 	def AnnAssign(node: ast.AST) -> TypeGuard[ast.AnnAssign]:
@@ -170,6 +181,14 @@ class be:
 	def ClassDef(node: ast.AST) -> TypeGuard[ast.ClassDef]:
 		return isinstance(node, ast.ClassDef)
 
+	@staticmethod
+	def Compare(node: ast.AST) -> TypeGuard[ast.Compare]:
+		return isinstance(node, ast.Compare)
+
+	@staticmethod
+	def Constant(node: ast.AST) -> TypeGuard[ast.Constant]:
+		return isinstance(node, ast.Constant)
+
 	@staticmethod
 	def FunctionDef(node: ast.AST) -> TypeGuard[ast.FunctionDef]:
 		return isinstance(node, ast.FunctionDef)
@@ -178,6 +197,18 @@ class be:
 	def keyword(node: ast.AST) -> TypeGuard[ast.keyword]:
 		return isinstance(node, ast.keyword)
 
+	@staticmethod
+	def If(node: ast.AST) -> TypeGuard[ast.If]:
+		return isinstance(node, ast.If)
+
+	@staticmethod
+	def Gt(node: ast.AST) -> TypeGuard[ast.Gt]:
+		return isinstance(node, ast.Gt)
+
+	@staticmethod
+	def LtE(node: ast.AST) -> TypeGuard[ast.LtE]:
+		return isinstance(node, ast.LtE)
+
 	@staticmethod
 	def Name(node: ast.AST) -> TypeGuard[ast.Name]:
 		return isinstance(node, ast.Name)
@@ -194,6 +225,14 @@ class be:
 	def Subscript(node: ast.AST) -> TypeGuard[ast.Subscript]:
 		return isinstance(node, ast.Subscript)
 
+	@staticmethod
+	def Tuple(node: ast.AST) -> TypeGuard[ast.Tuple]:
+		return isinstance(node, ast.Tuple)
+
+	@staticmethod
+	def While(node: ast.AST) -> TypeGuard[ast.While]:
+		return isinstance(node, ast.While)
+
 class ifThis:
 	"""
 	Provide predicate functions for matching and filtering AST nodes based on various criteria.
@@ -257,6 +296,29 @@ class ifThis:
 	def isAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Attribute] | bool]:
 		return lambda node: ifThis.isAttributeName(node) and ifThis.isName_Identifier(namespace)(DOT.value(node)) and ifThis._Identifier(identifier)(DOT.attr(node))
 
+	@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 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.While] | bool]:
+		return lambda node: (be.If(node)
+					and ifThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(node.test))
+
+	@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))
+
+	@staticmethod
+	def isAttributeNamespace_IdentifierLessThanOrEqual(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 be.LtE(node.ops[0]))
+
 	@staticmethod
 	def isAugAssign_targetIs(targetPredicate: Callable[[ast.expr], TypeGuard[ast.expr] | bool]) -> Callable[[ast.AST], TypeGuard[ast.AugAssign] | bool]:
 		def workhorse(node: ast.AST) -> TypeGuard[ast.AugAssign] | bool:
@@ -282,6 +344,10 @@ class ifThis:
 	def isClassDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.ClassDef] | bool]:
 		return lambda node: be.ClassDef(node) and ifThis._Identifier(identifier)(DOT.name(node))
 
+	@staticmethod
+	def isConstant_value(value: Any) -> Callable[[ast.AST], TypeGuard[ast.Constant] | bool]:
+		return lambda node: be.Constant(node) and DOT.value(node) == value
+
 	@staticmethod
 	def isFunctionDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.FunctionDef] | bool]:
 		return lambda node: be.FunctionDef(node) and ifThis._Identifier(identifier)(DOT.name(node))