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

mapFolding/someAssemblyRequired/Z0Z_makeSomeModules.py

@@ -2,11 +2,11 @@ from mapFolding import raiseIfNoneGitHubIssueNumber3, The
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
 	astModuleToIngredientsFunction,
-	be,
+	Be,
 	DOT,
 	extractFunctionDef,
-	grab,
-	ifThis,
+	Grab,
+	IfThis,
 	IngredientsFunction,
 	IngredientsModule,
 	LedgerOfImports,
@@ -35,7 +35,7 @@ sourceCallableIdentifierHARDCODED = 'count'
 logicalPathInfixHARDCODED: ast_Identifier = 'syntheticModules'
 theCountingIdentifierHARDCODED: ast_Identifier = 'groupsOfFolds'
 
-def makeInitializeGroupsOfFolds():
+def makeInitializeGroupsOfFolds() -> None:
 	callableIdentifierHARDCODED = 'initializeGroupsOfFolds'
 	moduleIdentifierHARDCODED: ast_Identifier = 'initializeCount'
 
@@ -53,24 +53,93 @@ def makeInitializeGroupsOfFolds():
 
 	countInitializeIngredients.astFunctionDef.name = callableIdentifier
 
-	dataclassInstanceIdentifier = NodeTourist(be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countInitializeIngredients.astFunctionDef)
+	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
+	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)
+	ingredientsModule = IngredientsModule(countInitializeIngredients)
 
 	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
 
-	write_astModule(initializationModule, pathFilename, The.packageName)
+	write_astModule(ingredientsModule, pathFilename, The.packageName)
 
-def makeTheorem2():
+def makeDaoOfMapFolding() -> PurePath:
+	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([astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
+	changeAssignCallToTarget = NodeChanger(findThis, doThat)
+	changeAssignCallToTarget.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() -> PurePath:
 	moduleIdentifierHARDCODED: ast_Identifier = 'theorem2'
 
 	algorithmSourceModule = algorithmSourceModuleHARDCODED
@@ -84,49 +153,80 @@ def makeTheorem2():
 	countTheorem2 = IngredientsFunction(inlineFunctionDef(sourceCallableIdentifier, astModule)
 		, LedgerOfImports(astModule))
 
-	dataclassInstanceIdentifier = NodeTourist(be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countTheorem2.astFunctionDef)
+	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
+	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')
+	findThis = IfThis.isIfAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Then.extractIt(DOT.body)
 	insertLeaf = NodeTourist(findThis, doThat).captureLastMatch(countTheorem2.astFunctionDef)
-	findThis = ifThis.isIfAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	findThis = IfThis.isIfAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Then.replaceWith(insertLeaf)
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
-	findThis = ifThis.isAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
+	findThis = IfThis.isAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Then.removeIt
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
-	findThis = ifThis.isAttributeNamespace_IdentifierLessThanOrEqual(dataclassInstanceIdentifier, 'leaf1ndex')
+	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
+	findThis = Be.Return
 	doThat = Then.insertThisAbove([doubleTheCount])
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
-	moduleTheorem2 = IngredientsModule(countTheorem2)
+	ingredientsModule = IngredientsModule(countTheorem2)
 
 	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
 
-	write_astModule(moduleTheorem2, pathFilename, The.packageName)
+	write_astModule(ingredientsModule, pathFilename, The.packageName)
+
+	return pathFilename
+
+def trimTheorem2(pathFilenameSource: PurePath) -> 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_alias=[Make.alias(ingredientsFunction.astFunctionDef.name)])
 
 	return pathFilename
 
-def numbaOnTheorem2(pathFilenameSource: PurePath):
+def numbaOnTheorem2(pathFilenameSource: PurePath) -> ast.ImportFrom:
 	logicalPathInfix = logicalPathInfixHARDCODED
 	sourceCallableIdentifier = sourceCallableIdentifierHARDCODED
 	countNumbaTheorem2 = astModuleToIngredientsFunction(parsePathFilename2astModule(pathFilenameSource), sourceCallableIdentifier)
-	dataclassName: ast.expr | None = NodeTourist(be.arg, Then.extractIt(DOT.annotation)).captureLastMatch(countNumbaTheorem2.astFunctionDef)
+	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)
+	dataclass_Identifier: ast_Identifier | None = NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
 	if dataclass_Identifier is None: raise raiseIfNoneGitHubIssueNumber3
 
 	dataclassLogicalPathModule = None
@@ -138,7 +238,7 @@ def numbaOnTheorem2(pathFilenameSource: PurePath):
 		if dataclassLogicalPathModule:
 			break
 	if dataclassLogicalPathModule is None: raise raiseIfNoneGitHubIssueNumber3
-	dataclassInstanceIdentifier = NodeTourist(be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countNumbaTheorem2.astFunctionDef)
+	dataclassInstanceIdentifier = NodeTourist(Be.arg, Then.extractIt(DOT.arg)).captureLastMatch(countNumbaTheorem2.astFunctionDef)
 	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
 	shatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclass_Identifier, dataclassInstanceIdentifier)
 
@@ -149,12 +249,12 @@ def numbaOnTheorem2(pathFilenameSource: PurePath):
 
 	countNumbaTheorem2 = decorateCallableWithNumba(countNumbaTheorem2, parametersNumbaLight)
 
-	moduleNumbaTheorem2 = IngredientsModule(countNumbaTheorem2)
-	moduleNumbaTheorem2.removeImportFromModule('numpy')
+	ingredientsModule = IngredientsModule(countNumbaTheorem2)
+	ingredientsModule.removeImportFromModule('numpy')
 
-	pathFilename = pathFilenameSource.with_stem(pathFilenameSource.stem + 'Numba')
+	pathFilename = pathFilenameSource.with_stem(pathFilenameSource.stem.replace('Trimmed', '') + 'Numba')
 
-	write_astModule(moduleNumbaTheorem2, pathFilename, The.packageName)
+	write_astModule(ingredientsModule, pathFilename, The.packageName)
 
 	logicalPath: list[str] = []
 	if The.packageName:
@@ -164,25 +264,24 @@ def numbaOnTheorem2(pathFilenameSource: PurePath):
 	logicalPath.append(pathFilename.stem)
 	moduleWithLogicalPath: str_nameDOTname = '.'.join(logicalPath)
 
-	astImportFrom: ast.ImportFrom = Make.ImportFrom(moduleWithLogicalPath, list_astAlias=[Make.alias(countNumbaTheorem2.astFunctionDef.name)])
+	astImportFrom: ast.ImportFrom = Make.ImportFrom(moduleWithLogicalPath, list_alias=[Make.alias(countNumbaTheorem2.astFunctionDef.name)])
 
 	return astImportFrom
 
-def makeUnRePackDataclass(astImportFrom: ast.ImportFrom):
+def makeUnRePackDataclass(astImportFrom: ast.ImportFrom) -> None:
 	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)
+	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)
+	dataclass_Identifier: ast_Identifier | None = NodeTourist(Be.Name, Then.extractIt(DOT.id)).captureLastMatch(dataclassName)
 	if dataclass_Identifier is None: raise raiseIfNoneGitHubIssueNumber3
 
 	dataclassLogicalPathModule = None
@@ -194,7 +293,7 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom):
 		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(doTheNeedful.astFunctionDef)
 	if dataclassInstanceIdentifier is None: raise raiseIfNoneGitHubIssueNumber3
 	shatteredDataclass = shatter_dataclassesDOTdataclass(dataclassLogicalPathModule, dataclass_Identifier, dataclassInstanceIdentifier)
 
@@ -204,23 +303,25 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom):
 	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)
+	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)))
+	findThis = IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(targetCallableIdentifier))
+	doThat = Then.replaceWith(Make.Assign([astTuple], value=Make.Call(Make.Name(targetCallableIdentifier), astTuple.elts)))
 	NodeChanger(findThis, doThat).visit(doTheNeedful.astFunctionDef)
 
-	moduleDoTheNeedful = IngredientsModule(doTheNeedful)
-	moduleDoTheNeedful.removeImportFromModule('numpy')
+	ingredientsModule = IngredientsModule(doTheNeedful)
+	ingredientsModule.removeImportFromModule('numpy')
 
 	pathFilename = PurePath(The.pathPackage, logicalPathInfix, moduleIdentifier + The.fileExtension)
 
-	write_astModule(moduleDoTheNeedful, pathFilename, The.packageName)
+	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,75 +1,59 @@
 """
 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,
 	ImaCallToName as ImaCallToName,
-	intORlist_ast_type_paramORstr_orNone as intORlist_ast_type_paramORstr_orNone,
-	intORstr_orNone as intORstr_orNone,
-	list_ast_type_paramORstr_orNone as list_ast_type_paramORstr_orNone,
 	NodeORattribute as NodeORattribute,
 	str_nameDOTname as str_nameDOTname,
 	个 as 个,
-	)
+)
+
+from mapFolding.someAssemblyRequired._astTypes import *  # noqa: F403
 
 from mapFolding.someAssemblyRequired._toolboxPython import (
 	importLogicalPath2Callable as importLogicalPath2Callable,
@@ -78,13 +62,18 @@ from mapFolding.someAssemblyRequired._toolboxPython import (
 	NodeTourist as NodeTourist,
 	parseLogicalPath2astModule as parseLogicalPath2astModule,
 	parsePathFilename2astModule as parsePathFilename2astModule,
-	)
+)
 
-from mapFolding.someAssemblyRequired._toolboxAntecedents import be as be, DOT as DOT, ifThis as ifThis
-from mapFolding.someAssemblyRequired._tool_Make import Make as Make
-from mapFolding.someAssemblyRequired._tool_Then import grab as grab, Then as Then
+from mapFolding.someAssemblyRequired._toolBe import Be as Be
+from mapFolding.someAssemblyRequired._toolDOT import DOT as DOT
+from mapFolding.someAssemblyRequired._toolGrab import Grab as Grab
+from mapFolding.someAssemblyRequired._toolMake import Make as Make
+
+from mapFolding.someAssemblyRequired._toolIfThis import IfThis as IfThis
+from mapFolding.someAssemblyRequired._toolThen import Then as Then
 
 from mapFolding.someAssemblyRequired._toolboxContainers import (
+	DeReConstructField2ast as DeReConstructField2ast,
 	IngredientsFunction as IngredientsFunction,
 	IngredientsModule as IngredientsModule,
 	LedgerOfImports as LedgerOfImports,
@@ -96,4 +85,4 @@ from mapFolding.someAssemblyRequired._toolboxAST import (
 	astModuleToIngredientsFunction as astModuleToIngredientsFunction,
 	extractClassDef as extractClassDef,
 	extractFunctionDef as extractFunctionDef,
-	)
+)

mapFolding/someAssemblyRequired/_astTypes.py

@@ -0,0 +1,117 @@
+"""This file is generated automatically, so changes to this file will be lost."""
+from mapFolding import astDOTParamSpec, astDOTTryStar, astDOTTypeAlias, astDOTTypeVar, astDOTTypeVarTuple, astDOTtype_param
+from typing import Any, TypeAlias as typing_TypeAlias
+import ast
+intORstr: typing_TypeAlias = Any
+intORstrORtype_params: typing_TypeAlias = Any
+intORtype_params: typing_TypeAlias = Any
+hasDOTannotation_expr: typing_TypeAlias = ast.AnnAssign
+hasDOTannotation_exprOrNone: typing_TypeAlias = ast.arg
+hasDOTannotation: typing_TypeAlias = hasDOTannotation_expr | hasDOTannotation_exprOrNone
+hasDOTarg_Identifier: typing_TypeAlias = ast.arg
+hasDOTarg_IdentifierOrNone: typing_TypeAlias = ast.keyword
+hasDOTarg: typing_TypeAlias = hasDOTarg_Identifier | hasDOTarg_IdentifierOrNone
+hasDOTargs_arguments: typing_TypeAlias = ast.FunctionDef | ast.AsyncFunctionDef | ast.Lambda
+hasDOTargs_list_expr: typing_TypeAlias = ast.Call
+hasDOTargs_list_arg: typing_TypeAlias = ast.arguments
+hasDOTargs: typing_TypeAlias = hasDOTargs_arguments | hasDOTargs_list_expr | hasDOTargs_list_arg
+hasDOTargtypes: typing_TypeAlias = ast.FunctionType
+hasDOTasname: typing_TypeAlias = ast.alias
+hasDOTattr: typing_TypeAlias = ast.Attribute
+hasDOTbases: typing_TypeAlias = ast.ClassDef
+hasDOTbody_list_stmt: typing_TypeAlias = ast.Module | ast.Interactive | ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef | ast.For | ast.AsyncFor | ast.While | ast.If | ast.With | ast.AsyncWith | ast.Try | ast.ExceptHandler | astDOTTryStar | ast.match_case
+hasDOTbody_expr: typing_TypeAlias = ast.Expression | ast.Lambda | ast.IfExp
+hasDOTbody: typing_TypeAlias = hasDOTbody_list_stmt | hasDOTbody_expr
+hasDOTbound: typing_TypeAlias = astDOTTypeVar
+hasDOTcases: typing_TypeAlias = ast.Match
+hasDOTcause: typing_TypeAlias = ast.Raise
+hasDOTcls: typing_TypeAlias = ast.MatchClass
+hasDOTcomparators: typing_TypeAlias = ast.Compare
+hasDOTcontext_expr: typing_TypeAlias = ast.withitem
+hasDOTconversion: typing_TypeAlias = ast.FormattedValue
+hasDOTctx: typing_TypeAlias = ast.Attribute | ast.Subscript | ast.Starred | ast.Name | ast.List | ast.Tuple
+hasDOTdecorator_list: typing_TypeAlias = ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef
+hasDOTdefault_value: typing_TypeAlias = astDOTTypeVar | astDOTParamSpec | astDOTTypeVarTuple
+hasDOTdefaults: typing_TypeAlias = ast.arguments
+hasDOTelt: typing_TypeAlias = ast.ListComp | ast.SetComp | ast.GeneratorExp
+hasDOTelts: typing_TypeAlias = ast.Set | ast.List | ast.Tuple
+hasDOTexc: typing_TypeAlias = ast.Raise
+hasDOTfinalbody: typing_TypeAlias = ast.Try | astDOTTryStar
+hasDOTformat_spec: typing_TypeAlias = ast.FormattedValue
+hasDOTfunc: typing_TypeAlias = ast.Call
+hasDOTgenerators: typing_TypeAlias = ast.ListComp | ast.SetComp | ast.DictComp | ast.GeneratorExp
+hasDOTguard: typing_TypeAlias = ast.match_case
+hasDOThandlers: typing_TypeAlias = ast.Try | astDOTTryStar
+hasDOTid: typing_TypeAlias = ast.Name
+hasDOTifs: typing_TypeAlias = ast.comprehension
+hasDOTis_async: typing_TypeAlias = ast.comprehension
+hasDOTitems: typing_TypeAlias = ast.With | ast.AsyncWith
+hasDOTiter: typing_TypeAlias = ast.For | ast.AsyncFor | ast.comprehension
+hasDOTkey: typing_TypeAlias = ast.DictComp
+hasDOTkeys_list_exprOrNone: typing_TypeAlias = ast.Dict
+hasDOTkeys_list_expr: typing_TypeAlias = ast.MatchMapping
+hasDOTkeys: typing_TypeAlias = hasDOTkeys_list_exprOrNone | hasDOTkeys_list_expr
+hasDOTkeywords: typing_TypeAlias = ast.ClassDef | ast.Call
+hasDOTkind: typing_TypeAlias = ast.Constant
+hasDOTkw_defaults: typing_TypeAlias = ast.arguments
+hasDOTkwarg: typing_TypeAlias = ast.arguments
+hasDOTkwd_attrs: typing_TypeAlias = ast.MatchClass
+hasDOTkwd_patterns: typing_TypeAlias = ast.MatchClass
+hasDOTkwonlyargs: typing_TypeAlias = ast.arguments
+hasDOTleft: typing_TypeAlias = ast.BinOp | ast.Compare
+hasDOTlevel: typing_TypeAlias = ast.ImportFrom
+hasDOTlineno: typing_TypeAlias = ast.TypeIgnore
+hasDOTlower: typing_TypeAlias = ast.Slice
+hasDOTmodule: typing_TypeAlias = ast.ImportFrom
+hasDOTmsg: typing_TypeAlias = ast.Assert
+hasDOTname_Identifier: typing_TypeAlias = ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef | astDOTTypeVar | astDOTParamSpec | astDOTTypeVarTuple
+hasDOTname_IdentifierOrNone: typing_TypeAlias = ast.ExceptHandler | ast.MatchStar | ast.MatchAs
+hasDOTname_str: typing_TypeAlias = ast.alias
+hasDOTname_Name: typing_TypeAlias = astDOTTypeAlias
+hasDOTname: typing_TypeAlias = hasDOTname_Identifier | hasDOTname_IdentifierOrNone | hasDOTname_str | hasDOTname_Name
+hasDOTnames_list_alias: typing_TypeAlias = ast.Import | ast.ImportFrom
+hasDOTnames_list_Identifier: typing_TypeAlias = ast.Global | ast.Nonlocal
+hasDOTnames: typing_TypeAlias = hasDOTnames_list_alias | hasDOTnames_list_Identifier
+hasDOTop_operator: typing_TypeAlias = ast.AugAssign | ast.BinOp
+hasDOTop_boolop: typing_TypeAlias = ast.BoolOp
+hasDOTop_unaryop: typing_TypeAlias = ast.UnaryOp
+hasDOTop: typing_TypeAlias = hasDOTop_operator | hasDOTop_boolop | hasDOTop_unaryop
+hasDOToperand: typing_TypeAlias = ast.UnaryOp
+hasDOTops: typing_TypeAlias = ast.Compare
+hasDOToptional_vars: typing_TypeAlias = ast.withitem
+hasDOTorelse_list_stmt: typing_TypeAlias = ast.For | ast.AsyncFor | ast.While | ast.If | ast.Try | astDOTTryStar
+hasDOTorelse_expr: typing_TypeAlias = ast.IfExp
+hasDOTorelse: typing_TypeAlias = hasDOTorelse_list_stmt | hasDOTorelse_expr
+hasDOTpattern_pattern: typing_TypeAlias = ast.match_case
+hasDOTpattern_patternOrNone: typing_TypeAlias = ast.MatchAs
+hasDOTpattern: typing_TypeAlias = hasDOTpattern_pattern | hasDOTpattern_patternOrNone
+hasDOTpatterns: typing_TypeAlias = ast.MatchSequence | ast.MatchMapping | ast.MatchClass | ast.MatchOr
+hasDOTposonlyargs: typing_TypeAlias = ast.arguments
+hasDOTrest: typing_TypeAlias = ast.MatchMapping
+hasDOTreturns_expr: typing_TypeAlias = ast.FunctionType
+hasDOTreturns_exprOrNone: typing_TypeAlias = ast.FunctionDef | ast.AsyncFunctionDef
+hasDOTreturns: typing_TypeAlias = hasDOTreturns_expr | hasDOTreturns_exprOrNone
+hasDOTright: typing_TypeAlias = ast.BinOp
+hasDOTsimple: typing_TypeAlias = ast.AnnAssign
+hasDOTslice: typing_TypeAlias = ast.Subscript
+hasDOTstep: typing_TypeAlias = ast.Slice
+hasDOTsubject: typing_TypeAlias = ast.Match
+hasDOTtag: typing_TypeAlias = ast.TypeIgnore
+hasDOTtarget_NameOrAttributeOrSubscript: typing_TypeAlias = ast.AugAssign | ast.AnnAssign
+hasDOTtarget_expr: typing_TypeAlias = ast.For | ast.AsyncFor | ast.comprehension
+hasDOTtarget_Name: typing_TypeAlias = ast.NamedExpr
+hasDOTtarget: typing_TypeAlias = hasDOTtarget_NameOrAttributeOrSubscript | hasDOTtarget_expr | hasDOTtarget_Name
+hasDOTtargets: typing_TypeAlias = ast.Delete | ast.Assign
+hasDOTtest: typing_TypeAlias = ast.While | ast.If | ast.Assert | ast.IfExp
+hasDOTtype: typing_TypeAlias = ast.ExceptHandler
+hasDOTtype_comment: typing_TypeAlias = ast.FunctionDef | ast.AsyncFunctionDef | ast.Assign | ast.For | ast.AsyncFor | ast.With | ast.AsyncWith | ast.arg
+hasDOTtype_ignores: typing_TypeAlias = ast.Module
+hasDOTtype_params: typing_TypeAlias = ast.FunctionDef | ast.AsyncFunctionDef | ast.ClassDef | astDOTTypeAlias
+hasDOTupper: typing_TypeAlias = ast.Slice
+hasDOTvalue_exprOrNone: typing_TypeAlias = ast.Return | ast.AnnAssign | ast.Yield
+hasDOTvalue_expr: typing_TypeAlias = ast.Assign | ast.AugAssign | ast.Expr | ast.NamedExpr | ast.DictComp | ast.Await | ast.YieldFrom | ast.FormattedValue | ast.Attribute | ast.Subscript | ast.Starred | ast.keyword | astDOTTypeAlias | ast.MatchValue
+hasDOTvalue_Any: typing_TypeAlias = ast.Constant
+hasDOTvalue_LiteralTrueFalseOrNone: typing_TypeAlias = ast.MatchSingleton
+hasDOTvalue: typing_TypeAlias = hasDOTvalue_exprOrNone | hasDOTvalue_expr | hasDOTvalue_Any | hasDOTvalue_LiteralTrueFalseOrNone
+hasDOTvalues: typing_TypeAlias = ast.BoolOp | ast.Dict | ast.JoinedStr
+hasDOTvararg: typing_TypeAlias = ast.arguments

mapFolding/someAssemblyRequired/_theTypes.py

@@ -1,49 +1,24 @@
-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"""
-	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:
-	astClassHasDOTbodyList_stmt = stuPyd
-	astClassHasDOTnameNotNameAlways = stuPyd
-	astClassHasDOTvalue_expr = stuPyd
+# TODO understand typing.
 
+# NOTE Prototype of an idea to subclass composable methods so that typing information
+# can extend beyond the top level of the ast node.
 class ImaCallToName(ast.Call):
-	func: ast.Name # pyright: ignore[reportIncompatibleVariableOverride]
-	# 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
-
-astClassHasDOTvalue_exprNone: typing_TypeAlias = ast.AnnAssign | ast.Return | ast.Yield
-astClassHasDOTvalue: typing_TypeAlias = ast.Constant | ast.MatchSingleton | astClassHasDOTvalue_expr | astClassHasDOTvalue_exprNone
+	func: ast.Name 	# pyright: ignore[reportIncompatibleVariableOverride]
 
+# 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
-intORstr_orNone: typing_TypeAlias = Any
-list_ast_type_paramORstr_orNone: typing_TypeAlias = Any
-str_nameDOTname: typing_TypeAlias = stuPyd
+str_nameDOTname: typing_TypeAlias = str
 
+# 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
@@ -53,11 +28,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