mapFolding 0.9.3__py3-none-any.whl → 0.9.5__py3-none-any.whl

mapFolding/someAssemblyRequired/Z0Z_makeSomeModules.py

@@ -0,0 +1,326 @@
+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])
+
+	ingredientsModule = IngredientsModule(countInitializeIngredients)
+
+	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
+
+	write_astModule(ingredientsModule, pathFilename, The.packageName)
+
+def makeDaoOfMapFolding():
+	moduleIdentifierHARDCODED: ast_Identifier = 'daoOfMapFolding'
+
+	algorithmSourceModule = algorithmSourceModuleHARDCODED
+	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
+	logicalPathSourceModule = '.'.join([The.packageName, algorithmSourceModule])
+
+	logicalPathInfix = logicalPathInfixHARDCODED
+	moduleIdentifier = moduleIdentifierHARDCODED
+
+	astModule = parseLogicalPath2astModule(logicalPathSourceModule)
+	daoOfMapFolding = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule)
+		, LedgerOfImports(astModule))
+
+	dataclassName: ast.expr | None = NodeTourist(be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(daoOfMapFolding.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 daoOfMapFolding.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(daoOfMapFolding.astFunctionDef)
+	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
+	shatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclass_Identifier, dataclassInstanceIdentifier)
+
+	# 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(daoOfMapFolding.astFunctionDef)
+
+	daoOfMapFolding.imports.update(shatteredDataclass.imports)
+	daoOfMapFolding = removeDataclassFromFunction(daoOfMapFolding, shatteredDataclass)
+
+	daoOfMapFolding = removeUnusedParameters(daoOfMapFolding)
+
+	daoOfMapFolding = decorateCallableWithNumba(daoOfMapFolding, parametersNumbaLight)
+
+	sourceCallableIdentifier = The.sourceCallableDispatcher
+
+	doTheNeedful: IngredientsFunction = astModuleToIngredientsFunction(astModule, sourceCallableIdentifier)
+	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)
+	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)
+
+	ingredientsModule = IngredientsModule([daoOfMapFolding, doTheNeedful])
+	ingredientsModule.removeImportFromModule('numpy')
+
+	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
+
+	write_astModule(ingredientsModule, pathFilename, The.packageName)
+
+	return pathFilename
+
+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)
+
+	ingredientsModule = IngredientsModule(countTheorem2)
+
+	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
+
+	write_astModule(ingredientsModule, pathFilename, The.packageName)
+
+	return pathFilename
+
+def trimTheorem2(pathFilenameSource: PurePath):
+	logicalPathInfix = logicalPathInfixHARDCODED
+	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
+	ingredientsFunction = astModuleToIngredientsFunction(parsePathFilename2astModule(pathFilenameSource), sourceCallableIdentifier)
+
+	dataclassInstanceIdentifier = NodeTourist(be.arg, Then.extractIt(DOT.arg)).captureLastMatch(ingredientsFunction.astFunctionDef)
+	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
+
+	findThis = ifThis.isIfUnaryNotAttributeNamespace_Identifier(dataclassInstanceIdentifier, 'dimensionsUnconstrained')
+	doThat = Then.removeIt
+	NodeChanger(findThis, doThat).visit(ingredientsFunction.astFunctionDef)
+
+	ingredientsModule = IngredientsModule(ingredientsFunction)
+	ingredientsModule.removeImportFromModule('numpy')
+
+	pathFilename = pathFilenameSource.with_stem(pathFilenameSource.stem + 'Trimmed')
+
+	write_astModule(ingredientsModule, 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(ingredientsFunction.astFunctionDef.name)])
+
+	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)
+
+	ingredientsModule = IngredientsModule(countNumbaTheorem2)
+	ingredientsModule.removeImportFromModule('numpy')
+
+	pathFilename = pathFilenameSource.with_stem(pathFilenameSource.stem.replace('Trimmed', '') + 'Numba')
+
+	write_astModule(ingredientsModule, 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])
+
+	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)
+
+	ingredientsModule = IngredientsModule(doTheNeedful)
+	ingredientsModule.removeImportFromModule('numpy')
+
+	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
+
+	write_astModule(ingredientsModule, pathFilename, The.packageName)
+
+if __name__ == '__main__':
+	makeInitializeGroupsOfFolds()
+	pathFilename = makeTheorem2()
+	pathFilename = trimTheorem2(pathFilename)
+	astImportFrom = numbaOnTheorem2(pathFilename)
+	makeUnRePackDataclass(astImportFrom)
+	makeDaoOfMapFolding()

mapFolding/someAssemblyRequired/__init__.py

@@ -1,63 +1,64 @@
 """
 Code Transformation Framework for Algorithm Optimization and Testing
 
-This package implements a comprehensive framework for programmatically analyzing,
-transforming, and generating optimized Python code. It serves as the algorithmic
-optimization engine for the mapFolding package, enabling the conversion of readable,
-functional implementations into highly-optimized variants with verified correctness.
+This package implements a comprehensive framework for programmatically analyzing, transforming, and generating optimized
+Python code. It serves as the algorithmic optimization engine for the mapFolding package, enabling the conversion of
+readable, functional implementations into highly-optimized variants with verified correctness.
 
 ## Core Architecture Components
 
 1. **AST Manipulation Tools**
-   - Pattern recognition with composable predicates (ifThis)
-   - Node access with consistent interfaces (DOT)
-   - AST traversal and transformation (NodeChanger, NodeTourist)
-   - AST construction with sane defaults (Make)
-   - Node transformation operations (grab, Then)
+	- Pattern recognition with composable predicates (ifThis)
+	- Node access with consistent interfaces (DOT)
+	- AST traversal and transformation (NodeChanger, NodeTourist)
+	- AST construction with sane defaults (Make)
+	- Node transformation operations (grab, Then)
 
 2. **Container and Organization**
-   - Import tracking and management (LedgerOfImports)
-   - Function packaging with dependencies (IngredientsFunction)
-   - Module assembly with structured components (IngredientsModule)
-   - Recipe configuration for generating optimized code (RecipeSynthesizeFlow)
-   - Dataclass decomposition for compatibility (ShatteredDataclass)
+	- Import tracking and management (LedgerOfImports)
+	- Function packaging with dependencies (IngredientsFunction)
+	- Module assembly with structured components (IngredientsModule)
+	- Recipe configuration for generating optimized code (RecipeSynthesizeFlow)
+	- Dataclass decomposition for compatibility (ShatteredDataclass)
 
 3. **Optimization assembly lines**
-   - General-purpose Numba acceleration (makeNumbaFlow)
-   - Job-specific optimization for concrete parameters (makeJobNumba)
-   - Specialized component transformation (decorateCallableWithNumba)
+	- General-purpose Numba acceleration (makeNumbaFlow)
+	- Job-specific optimization for concrete parameters (makeJobNumba)
+	- Specialized component transformation (decorateCallableWithNumba)
 
 ## Integration with Testing Framework
 
-The transformation components are extensively tested through the package's test suite,
-which provides specialized fixtures and utilities for validating both the transformation
-process and the resulting optimized code:
+The transformation components are extensively tested through the package's test suite, which provides specialized
+fixtures and utilities for validating both the transformation process and the resulting optimized code:
 
-- **syntheticDispatcherFixture**: Creates and tests a complete Numba-optimized module
-  using RecipeSynthesizeFlow configuration
+- **syntheticDispatcherFixture**: Creates and tests a complete Numba-optimized module using RecipeSynthesizeFlow
+	configuration
 
 - **test_writeJobNumba**: Tests the job-specific optimization process with RecipeJob
 
-These fixtures enable users to test their own custom recipes and job configurations
-with minimal effort. See the documentation in tests/__init__.py for details on
-extending the test suite for custom implementations.
+These fixtures enable users to test their own custom recipes and job configurations with minimal effort. See the
+documentation in tests/__init__.py for details on extending the test suite for custom implementations.
 
-The framework balances multiple optimization levels - from general algorithmic
-improvements to parameter-specific optimizations - while maintaining the ability
-to verify correctness at each transformation stage through the integrated test suite.
+The framework balances multiple optimization levels - from general algorithmic improvements to parameter-specific
+optimizations - while maintaining the ability to verify correctness at each transformation stage through the integrated
+test suite.
 """
 
 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,
@@ -81,9 +82,16 @@ from mapFolding.someAssemblyRequired._tool_Make import Make as Make
 from mapFolding.someAssemblyRequired._tool_Then import grab as grab, Then as Then
 
 from mapFolding.someAssemblyRequired._toolboxContainers import (
+	DeReConstructField2ast as DeReConstructField2ast,
 	IngredientsFunction as IngredientsFunction,
 	IngredientsModule as IngredientsModule,
 	LedgerOfImports as LedgerOfImports,
 	RecipeSynthesizeFlow as RecipeSynthesizeFlow,
 	ShatteredDataclass as ShatteredDataclass,
 )
+
+from mapFolding.someAssemblyRequired._toolboxAST import (
+	astModuleToIngredientsFunction as astModuleToIngredientsFunction,
+	extractClassDef as extractClassDef,
+	extractFunctionDef as extractFunctionDef,
+	)

mapFolding/someAssemblyRequired/_theTypes.py

@@ -1,32 +1,35 @@
-from typing import Any, TYPE_CHECKING, TypeAlias as typing_TypeAlias, TypeVar as typing_TypeVar
+from mapFolding import astDOTParamSpec, astDOTTryStar, astDOTtype_param, astDOTTypeAlias, astDOTTypeVar, astDOTTypeVarTuple
+from typing import Any, TypeAlias as typing_TypeAlias, TypeVar as typing_TypeVar
 import ast
+
 # TODO understand typing.
 
 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
-	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
-	astClassHasDOTvalue_expr = stuPyd
 
+# NOTE An idea to subclass antecedents to effectively TypeGuard more than just the top level of the antecedent.
 class ImaCallToName(ast.Call):
 	func: ast.Name # pyright: ignore[reportIncompatibleVariableOverride]
 	# assert isinstance(ast.Call.func, ast.Name), "brinkmanship"
 	# func: ast.Name
 
+# Some common attributes of ast classes.
+astClassHasDOTbody_expr: typing_TypeAlias = ast.Expression | ast.IfExp | ast.Lambda
+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 | astDOTTryStar | ast.While | ast.With
+astClassHasDOTbody: typing_TypeAlias = astClassHasDOTbody_expr | astClassHasDOTbodyList_stmt
+
+astClassHasDOTnameNotNameAlways: typing_TypeAlias = ast.alias | ast.AsyncFunctionDef | ast.ClassDef | ast.FunctionDef | astDOTParamSpec | astDOTTypeVar | astDOTTypeVarTuple
+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_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 | astDOTTypeAlias | ast.YieldFrom
 astClassHasDOTvalue_exprNone: typing_TypeAlias = ast.AnnAssign | ast.Return | ast.Yield
 astClassHasDOTvalue: typing_TypeAlias = ast.Constant | ast.MatchSingleton | astClassHasDOTvalue_expr | astClassHasDOTvalue_exprNone
 
+# Type hints through TypeAlias or type "hints" through the identifier name.
 ast_expr_Slice: typing_TypeAlias = ast.expr
 ast_Identifier: typing_TypeAlias = str
 intORlist_ast_type_paramORstr_orNone: typing_TypeAlias = Any
@@ -34,10 +37,11 @@ intORstr_orNone: typing_TypeAlias = Any
 list_ast_type_paramORstr_orNone: typing_TypeAlias = Any
 str_nameDOTname: typing_TypeAlias = stuPyd
 
+# Limited success with TypeVar.
 个 = typing_TypeVar('个', bound = ast.AST, covariant = True)
 NodeORattribute = typing_TypeVar('NodeORattribute', bound = ast.AST | ast_expr_Slice | ast_Identifier | str_nameDOTname | bool | Any | None, covariant = True)
 
-# All ast classes by subgroup:
+# For my reference, all ast classes by subgroup:
 Ima_ast_boolop: typing_TypeAlias = ast.boolop | ast.And | ast.Or
 Ima_ast_cmpop: typing_TypeAlias = ast.cmpop | ast.Eq | ast.NotEq | ast.Lt | ast.LtE | ast.Gt | ast.GtE | ast.Is | ast.IsNot | ast.In | ast.NotIn
 Ima_ast_excepthandler: typing_TypeAlias = ast.excepthandler | ast.ExceptHandler
@@ -47,11 +51,7 @@ Ima_ast_mod: typing_TypeAlias = ast.mod | ast.Expression | ast.FunctionType | as
 Ima_ast_operator: typing_TypeAlias = ast.operator | ast.Add | ast.Sub | ast.Mult | ast.MatMult | ast.Div | ast.Mod | ast.Pow | ast.LShift | ast.RShift | ast.BitOr | ast.BitXor | ast.BitAnd | ast.FloorDiv
 Ima_ast_orphan = ast.alias | ast.arg | ast.arguments | ast.comprehension | ast.keyword | ast.match_case | ast.withitem
 iMa_ast_pattern: typing_TypeAlias = ast.pattern | ast.MatchAs | ast.MatchClass | ast.MatchMapping | ast.MatchOr | ast.MatchSequence | ast.MatchSingleton | ast.MatchStar | ast.MatchValue
+Ima_ast_stmt: typing_TypeAlias = ast.stmt | ast.AnnAssign | ast.Assert | ast.Assign | ast.AsyncFor | ast.AsyncFunctionDef | ast.AsyncWith | ast.AugAssign | ast.Break | ast.ClassDef | ast.Continue | ast.Delete | ast.Expr | ast.For | ast.FunctionDef | ast.Global | ast.If | ast.Import | ast.ImportFrom | ast.Match | ast.Nonlocal | ast.Pass | ast.Raise | ast.Return | ast.Try | astDOTTryStar | astDOTTypeAlias | ast.While | ast.With
 Ima_ast_type_ignore: typing_TypeAlias = ast.type_ignore | ast.TypeIgnore
+Ima_ast_type_param: typing_TypeAlias = astDOTtype_param | astDOTParamSpec | astDOTTypeVar | astDOTTypeVarTuple
 Ima_ast_unaryop: typing_TypeAlias = ast.unaryop | ast.Invert | ast.Not | ast.UAdd | ast.USub
-if TYPE_CHECKING:
-	Ima_ast_stmt: typing_TypeAlias = ast.stmt | ast.AnnAssign | ast.Assert | ast.Assign | ast.AsyncFor | ast.AsyncFunctionDef | ast.AsyncWith | ast.AugAssign | ast.Break | ast.ClassDef | ast.Continue | ast.Delete | ast.Expr | ast.For | ast.FunctionDef | ast.Global | ast.If | ast.Import | ast.ImportFrom | ast.Match | ast.Nonlocal | ast.Pass | ast.Raise | ast.Return | ast.Try | ast.TryStar | ast.TypeAlias | ast.While | ast.With
-	Ima_ast_type_param: typing_TypeAlias = ast.type_param | ast.ParamSpec | ast.TypeVar | ast.TypeVarTuple
-else:
-	Ima_ast_stmt = stuPyd
-	Ima_ast_type_param = stuPyd

mapFolding/someAssemblyRequired/_tool_Make.py

@@ -1,13 +1,11 @@
 """
 AST Node Construction Utilities for Python Code Generation
 
-This module provides the Make class with static methods for creating AST nodes
-with sane defaults. It abstracts away the complexity of constructing AST nodes
-directly, making programmatic code generation more intuitive and less error-prone.
+This module provides the Make class with static methods for creating AST nodes with sane defaults. It abstracts away the
+complexity of constructing AST nodes directly, making programmatic code generation more intuitive and less error-prone.
 
-The Make class serves as a factory for creating various types of AST nodes needed
-in code generation, transformation, and analysis workflows. Each method follows
-a consistent pattern that maps cleanly to Python's syntax while handling the
+The Make class serves as a factory for creating various types of AST nodes needed in code generation, transformation,
+and analysis workflows. Each method follows a consistent pattern that maps cleanly to Python's syntax while handling the
 details of AST node construction.
 """
 
@@ -73,6 +71,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 +126,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)