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

mapFolding/someAssemblyRequired/_toolboxAntecedents.py

@@ -2,17 +2,22 @@
 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 two primary classes:
+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.
 
-2. ifThis: Contains predicate functions for matching AST nodes based on various criteria,
+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.
 
 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.
+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
@@ -26,6 +31,7 @@ from mapFolding.someAssemblyRequired import (
 	astClassHasDOTvalue_expr,
 	astClassOptionallyHasDOTnameNotName,
 	astClassHasDOTvalue_exprNone,
+	ImaCallToName,
 )
 from typing import Any, overload, TypeGuard
 import ast
@@ -65,9 +71,17 @@ class DOT:
 	@staticmethod
 	def attr(node: ast.Attribute) -> ast_Identifier:
 		return node.attr
+
+	@staticmethod
+	@overload
+	def func(node: ImaCallToName) -> ast.Name:...
 	@staticmethod
-	def func(node: ast.Call) -> ast.expr:
+	@overload
+	def func(node: ast.Call) -> ast.expr:...
+	@staticmethod
+	def func(node: ast.Call | ImaCallToName) -> ast.expr | ast.Name:
 		return node.func
+
 	@staticmethod
 	def id(node: ast.Name) -> ast_Identifier:
 		return node.id
@@ -111,6 +125,75 @@ class DOT:
 	def value(node: astClassHasDOTvalue) -> Any | ast.expr | bool | None:
 		return node.value
 
+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:
+
+	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.
+	"""
+	@staticmethod
+	def AnnAssign(node: ast.AST) -> TypeGuard[ast.AnnAssign]:
+		return isinstance(node, ast.AnnAssign)
+
+	@staticmethod
+	def arg(node: ast.AST) -> TypeGuard[ast.arg]:
+		return isinstance(node, ast.arg)
+
+	@staticmethod
+	def Assign(node: ast.AST) -> TypeGuard[ast.Assign]:
+		return isinstance(node, ast.Assign)
+
+	@staticmethod
+	def Attribute(node: ast.AST) -> TypeGuard[ast.Attribute]:
+		return isinstance(node, ast.Attribute)
+
+	@staticmethod
+	def AugAssign(node: ast.AST) -> TypeGuard[ast.AugAssign]:
+		return isinstance(node, ast.AugAssign)
+
+	@staticmethod
+	def Call(node: ast.AST) -> TypeGuard[ast.Call]:
+		return isinstance(node, ast.Call)
+
+	@staticmethod
+	def ClassDef(node: ast.AST) -> TypeGuard[ast.ClassDef]:
+		return isinstance(node, ast.ClassDef)
+
+	@staticmethod
+	def FunctionDef(node: ast.AST) -> TypeGuard[ast.FunctionDef]:
+		return isinstance(node, ast.FunctionDef)
+
+	@staticmethod
+	def keyword(node: ast.AST) -> TypeGuard[ast.keyword]:
+		return isinstance(node, ast.keyword)
+
+	@staticmethod
+	def Name(node: ast.AST) -> TypeGuard[ast.Name]:
+		return isinstance(node, ast.Name)
+
+	@staticmethod
+	def Return(node: ast.AST) -> TypeGuard[ast.Return]:
+		return isinstance(node, ast.Return)
+
+	@staticmethod
+	def Starred(node: ast.AST) -> TypeGuard[ast.Starred]:
+		return isinstance(node, ast.Starred)
+
+	@staticmethod
+	def Subscript(node: ast.AST) -> TypeGuard[ast.Subscript]:
+		return isinstance(node, ast.Subscript)
+
 class ifThis:
 	"""
 	Provide predicate functions for matching and filtering AST nodes based on various criteria.
@@ -135,41 +218,41 @@ class ifThis:
 	@staticmethod
 	def is_arg_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.arg] | bool]:
 		"""see also `isArgument_Identifier`"""
-		return lambda node: isinstance(node, ast.arg) and ifThis._Identifier(identifier)(DOT.arg(node))
+		return lambda node: be.arg(node) and ifThis._Identifier(identifier)(DOT.arg(node))
 	@staticmethod
 	def is_keyword_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.keyword] | bool]:
 		"""see also `isArgument_Identifier`"""
-		return lambda node: isinstance(node, ast.keyword) and ifThis._Identifier(identifier)(DOT.arg(node))
+		return lambda node: be.keyword(node) and ifThis._Identifier(identifier)(DOT.arg(node))
 
 	@staticmethod
 	def isAnnAssign_targetIs(targetPredicate: Callable[[ast.expr], TypeGuard[ast.expr] | bool]) -> Callable[[ast.AST], TypeGuard[ast.AnnAssign] | bool]:
 		def workhorse(node: ast.AST) -> TypeGuard[ast.AnnAssign] | bool:
-			return isinstance(node, ast.AnnAssign) and targetPredicate(DOT.target(node))
+			return be.AnnAssign(node) and targetPredicate(DOT.target(node))
 		return workhorse
 
 	@staticmethod
 	def isArgument_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.arg | ast.keyword] | bool]:
-		return lambda node: (isinstance(node, ast.arg) or isinstance(node, ast.keyword)) and ifThis._Identifier(identifier)(DOT.arg(node))
+		return lambda node: (be.arg(node) or be.keyword(node)) and ifThis._Identifier(identifier)(DOT.arg(node))
 
 	@staticmethod
 	def isAssignAndTargets0Is(targets0Predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], TypeGuard[ast.AnnAssign] | bool]:
 		"""node is Assign and node.targets[0] matches `targets0Predicate`."""
-		return lambda node: isinstance(node, ast.Assign) and targets0Predicate(node.targets[0])
+		return lambda node: be.Assign(node) and targets0Predicate(node.targets[0])
 	@staticmethod
 	def isAssignAndValueIs(valuePredicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], TypeGuard[ast.Assign] | bool]:
 		"""node is ast.Assign and node.value matches `valuePredicate`. """
-		return lambda node: isinstance(node, ast.Assign) and valuePredicate(DOT.value(node))
+		return lambda node: be.Assign(node) and valuePredicate(DOT.value(node))
 
 	@staticmethod
 	def isAttribute_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Attribute] | bool]:
 		"""node is `ast.Attribute` and the top-level `ast.Name` is `identifier`"""
 		def workhorse(node: ast.AST) -> TypeGuard[ast.Attribute]:
-			return isinstance(node, ast.Attribute) and ifThis._nested_Identifier(identifier)(DOT.value(node))
+			return be.Attribute(node) and ifThis._nested_Identifier(identifier)(DOT.value(node))
 		return workhorse
 	@staticmethod
 	def isAttributeName(node: ast.AST) -> TypeGuard[ast.Attribute]:
 		""" Displayed as Name.attribute."""
-		return isinstance(node, ast.Attribute) and isinstance(DOT.value(node), ast.Name)
+		return be.Attribute(node) and be.Name(DOT.value(node))
 	@staticmethod
 	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))
@@ -177,42 +260,47 @@ class ifThis:
 	@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:
-			return isinstance(node, ast.AugAssign) and targetPredicate(DOT.target(node))
+			return be.AugAssign(node) and targetPredicate(DOT.target(node))
 		return workhorse
 
 	@staticmethod
-	def isCall_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Call] | bool]:
-		return lambda node: isinstance(node, ast.Call) and ifThis.isName_Identifier(identifier)(DOT.func(node))
+	def isCall_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ImaCallToName] | bool]:
+		def workhorse(node: ast.AST) -> TypeGuard[ImaCallToName] | bool:
+			return ifThis.isCallToName(node) and ifThis._Identifier(identifier)(DOT.id(DOT.func(node)))
+		return workhorse
+
 	@staticmethod
 	def isCallAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Call] | bool]:
-		return lambda node: isinstance(node, ast.Call) and ifThis.isAttributeNamespace_Identifier(namespace, identifier)(DOT.func(node))
+		def workhorse(node: ast.AST) -> TypeGuard[ast.Call] | bool:
+			return be.Call(node) and ifThis.isAttributeNamespace_Identifier(namespace, identifier)(DOT.func(node))
+		return workhorse
 	@staticmethod
-	def isCallToName(node: ast.AST) -> TypeGuard[ast.Call]:
-		return isinstance(node, ast.Call) and isinstance(DOT.func(node), ast.Name)
+	def isCallToName(node: ast.AST) -> TypeGuard[ImaCallToName]:
+		return be.Call(node) and be.Name(DOT.func(node))
 
 	@staticmethod
 	def isClassDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.ClassDef] | bool]:
-		return lambda node: isinstance(node, ast.ClassDef) and ifThis._Identifier(identifier)(DOT.name(node))
+		return lambda node: be.ClassDef(node) and ifThis._Identifier(identifier)(DOT.name(node))
 
 	@staticmethod
 	def isFunctionDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.FunctionDef] | bool]:
-		return lambda node: isinstance(node, ast.FunctionDef) and ifThis._Identifier(identifier)(DOT.name(node))
+		return lambda node: be.FunctionDef(node) and ifThis._Identifier(identifier)(DOT.name(node))
 
 	@staticmethod
 	def isName_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Name] | bool]:
-		return lambda node: isinstance(node, ast.Name) and ifThis._Identifier(identifier)(DOT.id(node))
+		return lambda node: be.Name(node) and ifThis._Identifier(identifier)(DOT.id(node))
 
 	@staticmethod
 	def isStarred_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Starred] | bool]:
 		"""node is `ast.Starred` and the top-level `ast.Name` is `identifier`"""
 		def workhorse(node: ast.AST) -> TypeGuard[ast.Starred]:
-			return isinstance(node, ast.Starred) and ifThis._nested_Identifier(identifier)(DOT.value(node))
+			return be.Starred(node) and ifThis._nested_Identifier(identifier)(DOT.value(node))
 		return workhorse
 	@staticmethod
 	def isSubscript_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Subscript] | bool]:
 		"""node is `ast.Subscript` and the top-level `ast.Name` is `identifier`"""
 		def workhorse(node: ast.AST) -> TypeGuard[ast.Subscript]:
-			return isinstance(node, ast.Subscript) and ifThis._nested_Identifier(identifier)(DOT.value(node))
+			return be.Subscript(node) and ifThis._nested_Identifier(identifier)(DOT.value(node))
 		return workhorse
 
 	@staticmethod
@@ -231,15 +319,3 @@ class ifThis:
 	def Z0Z_unparseIs(astAST: ast.AST) -> Callable[[ast.AST], bool]:
 		def workhorse(node: ast.AST) -> bool: return ast.unparse(node) == ast.unparse(astAST)
 		return workhorse
-
-
-class be:
-	@staticmethod
-	def Call(node: ast.AST) -> TypeGuard[ast.Call]:
-		return isinstance(node, ast.Call)
-	@staticmethod
-	def Name(node: ast.AST) -> TypeGuard[ast.Name]:
-		return isinstance(node, ast.Name)
-	@staticmethod
-	def Return(node: ast.AST) -> TypeGuard[ast.Return]:
-		return isinstance(node, ast.Return)

mapFolding/someAssemblyRequired/_toolboxContainers.py

@@ -1,23 +1,21 @@
 """
 AST Container Classes for Python Code Generation and Transformation
 
-This module provides specialized container classes that organize AST nodes, imports,
-and program structure for code generation and transformation. These classes form
-the organizational backbone of the code generation system, enabling:
-
-1. Tracking and managing imports with LedgerOfImports
-2. Packaging function definitions with their dependencies via IngredientsFunction
-3. Structuring complete modules with IngredientsModule
-4. Configuring code synthesis with RecipeSynthesizeFlow
-5. Organizing decomposed dataclass representations with ShatteredDataclass
-
-Together, these container classes implement a component-based architecture for
-programmatic generation of high-performance code. They maintain a clean separation
-between structure and content, allowing transformations to be applied systematically
-while preserving relationships between code elements.
-
-The containers work in conjunction with transformation tools that manipulate the
-contained AST nodes to implement specific optimizations and transformations.
+This module provides specialized container classes that organize AST nodes, imports, and program structure for code
+generation and transformation. These classes form the organizational backbone of the code generation system, enabling:
+
+1. Tracking and managing imports with LedgerOfImports.
+2. Packaging function definitions with their dependencies via IngredientsFunction.
+3. Structuring complete modules with IngredientsModule.
+4. Configuring code synthesis with RecipeSynthesizeFlow.
+5. Organizing decomposed dataclass representations with ShatteredDataclass.
+
+Together, these container classes implement a component-based architecture for programmatic generation of
+high-performance code. They maintain a clean separation between structure and content, allowing transformations to be
+applied systematically while preserving relationships between code elements.
+
+The containers work in conjunction with transformation tools that manipulate the contained AST nodes to implement
+specific optimizations and transformations.
 """
 
 from collections import defaultdict
@@ -33,30 +31,31 @@ class LedgerOfImports:
 	"""
 	Track and manage import statements for programmatically generated code.
 
-	LedgerOfImports acts as a registry for import statements, maintaining a clean
-	separation between the logical structure of imports and their textual representation.
+	LedgerOfImports acts as a registry for import statements, maintaining a clean separation between the logical
+	structure of imports and their textual representation.
 	It enables:
 
-	1. Tracking regular imports and import-from statements
-	2. Adding imports programmatically during code transformation
-	3. Merging imports from multiple sources
-	4. Removing unnecessary or conflicting imports
-	5. Generating optimized AST import nodes for the final code
+	1. Tracking regular imports and import-from statements.
+	2. Adding imports programmatically during code transformation.
+	3. Merging imports from multiple sources.
+	4. Removing unnecessary or conflicting imports.
+	5. Generating optimized AST import nodes for the final code.
 
-	This class forms the foundation of dependency management in generated code,
-	ensuring that all required libraries are available without duplication or
-	conflict.
+	This class forms the foundation of dependency management in generated code, ensuring that all required libraries are
+	available without duplication or conflict.
 	"""
 	# TODO When resolving the ledger of imports, remove self-referential imports
-	# TODO add TypeIgnore tracking to the ledger of imports
 
-	def __init__(self, startWith: ast.AST | None = None) -> None:
+	type_ignores: list[ast.TypeIgnore]
+
+	def __init__(self, startWith: ast.AST | None = None, type_ignores: list[ast.TypeIgnore] | None = None) -> None:
 		self.dictionaryImportFrom: dict[str_nameDOTname, list[tuple[ast_Identifier, ast_Identifier | None]]] = defaultdict(list)
 		self.listImport: list[str_nameDOTname] = []
+		self.type_ignores = [] if type_ignores is None else list(type_ignores)
 		if startWith:
 			self.walkThis(startWith)
 
-	def addAst(self, astImport____: ast.Import | ast.ImportFrom) -> None:
+	def addAst(self, astImport____: ast.Import | ast.ImportFrom, type_ignores: list[ast.TypeIgnore] | None = None) -> None:
 		match astImport____:
 			case ast.Import():
 				for alias in astImport____.names:
@@ -69,14 +68,20 @@ class LedgerOfImports:
 					self.dictionaryImportFrom[astImport____.module].append((alias.name, alias.asname))
 			case _:
 				raise ValueError(f"I received {type(astImport____) = }, but I can only accept {ast.Import} and {ast.ImportFrom}.")
+		if type_ignores:
+			self.type_ignores.extend(type_ignores)
 
-	def addImport_asStr(self, moduleWithLogicalPath: str_nameDOTname) -> None:
+	def addImport_asStr(self, moduleWithLogicalPath: str_nameDOTname, type_ignores: list[ast.TypeIgnore] | None = None) -> None:
 		self.listImport.append(moduleWithLogicalPath)
+		if type_ignores:
+			self.type_ignores.extend(type_ignores)
 
-	def addImportFrom_asStr(self, moduleWithLogicalPath: str_nameDOTname, name: ast_Identifier, asname: ast_Identifier | None = None) -> None:
+	def addImportFrom_asStr(self, moduleWithLogicalPath: str_nameDOTname, name: ast_Identifier, asname: ast_Identifier | None = None, type_ignores: list[ast.TypeIgnore] | None = None) -> None:
 		if moduleWithLogicalPath not in self.dictionaryImportFrom:
 			self.dictionaryImportFrom[moduleWithLogicalPath] = []
 		self.dictionaryImportFrom[moduleWithLogicalPath].append((name, asname))
+		if type_ignores:
+			self.type_ignores.extend(type_ignores)
 
 	def removeImportFromModule(self, moduleWithLogicalPath: str_nameDOTname) -> None:
 		"""Remove all imports from a specific module."""
@@ -129,11 +134,14 @@ class LedgerOfImports:
 		self.dictionaryImportFrom = updateExtendPolishDictionaryLists(self.dictionaryImportFrom, *(ledger.dictionaryImportFrom for ledger in fromLedger), destroyDuplicates=True, reorderLists=True)
 		for ledger in fromLedger:
 			self.listImport.extend(ledger.listImport)
+			self.type_ignores.extend(ledger.type_ignores)
 
-	def walkThis(self, walkThis: ast.AST) -> None:
+	def walkThis(self, walkThis: ast.AST, type_ignores: list[ast.TypeIgnore] | None = None) -> None:
 		for nodeBuffalo in ast.walk(walkThis):
 			if isinstance(nodeBuffalo, (ast.Import, ast.ImportFrom)):
 				self.addAst(nodeBuffalo)
+		if type_ignores:
+			self.type_ignores.extend(type_ignores)
 
 # Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
 @dataclasses.dataclass
@@ -141,17 +149,16 @@ class IngredientsFunction:
 	"""
 	Package a function definition with its import dependencies for code generation.
 
-	IngredientsFunction encapsulates an AST function definition along with all the
-	imports required for that function to operate correctly. This creates a modular,
-	portable unit that can be:
+	IngredientsFunction encapsulates an AST function definition along with all the imports required for that function to
+	operate correctly. This creates a modular, portable unit that can be:
 
-	1. Transformed independently (e.g., by applying Numba decorators)
-	2. Transplanted between modules while maintaining dependencies
-	3. Combined with other functions to form complete modules
-	4. Analyzed for optimization opportunities
+	1. Transformed independently (e.g., by applying Numba decorators).
+	2. Transplanted between modules while maintaining dependencies.
+	3. Combined with other functions to form complete modules.
+	4. Analyzed for optimization opportunities.
 
-	This class forms the primary unit of function manipulation in the code generation
-	system, enabling targeted transformations while preserving function dependencies.
+	This class forms the primary unit of function manipulation in the code generation system, enabling targeted
+	transformations while preserving function dependencies.
 
 	Parameters:
 		astFunctionDef: The AST representation of the function definition
@@ -251,7 +258,6 @@ class IngredientsModule:
 	def appendIngredientsFunction(self, *ingredientsFunction: IngredientsFunction) -> None:
 		"""Append one or more `IngredientsFunction`."""
 		for allegedIngredientsFunction in ingredientsFunction:
-			assert isinstance(allegedIngredientsFunction, IngredientsFunction), ValueError(f"I received `{type(allegedIngredientsFunction) = }`, but I can only accept `{IngredientsFunction}`.")
 			self.listIngredientsFunctions.append(allegedIngredientsFunction)
 
 	def removeImportFromModule(self, moduleWithLogicalPath: str_nameDOTname) -> None:
@@ -267,15 +273,18 @@ class IngredientsModule:
 		for ingredientsFunction in self.listIngredientsFunctions:
 			ingredientsFunction.imports.removeImportFrom(moduleWithLogicalPath, name, asname)
 
-	@property
-	def list_astImportImportFrom(self) -> list[ast.Import | ast.ImportFrom]:
-		"""List of `ast.Import` and `ast.ImportFrom` statements."""
+	def _consolidatedLedger(self) -> LedgerOfImports:
+		"""Consolidate all ledgers of imports."""
 		sherpaLedger = LedgerOfImports()
 		listLedgers: list[LedgerOfImports] = [self.imports]
 		for ingredientsFunction in self.listIngredientsFunctions:
 			listLedgers.append(ingredientsFunction.imports)
 		sherpaLedger.update(*listLedgers)
-		return sherpaLedger.makeList_ast()
+		return sherpaLedger
+
+	@property
+	def list_astImportImportFrom(self) -> list[ast.Import | ast.ImportFrom]:
+		return self._consolidatedLedger().makeList_ast()
 
 	@property
 	def body(self) -> list[ast.stmt]:
@@ -292,7 +301,7 @@ class IngredientsModule:
 	@property
 	def type_ignores(self) -> list[ast.TypeIgnore]:
 		listTypeIgnore: list[ast.TypeIgnore] = self.supplemental_type_ignores
-		# listTypeIgnore.extend(self.imports.makeListAst())
+		listTypeIgnore.extend(self._consolidatedLedger().type_ignores)
 		listTypeIgnore.extend(self.prologue.type_ignores)
 		for ingredientsFunction in self.listIngredientsFunctions:
 			listTypeIgnore.extend(ingredientsFunction.type_ignores)
@@ -317,7 +326,7 @@ class RecipeSynthesizeFlow:
 
 	This configuration class serves as a single source of truth for the code generation
 	process, ensuring consistency across all generated artifacts while enabling
-	customization of the transformation pipeline.
+	customization of the transformation assembly line.
 
 	The transformation process uses this configuration to extract functions from the
 	source module, transform them according to optimization rules, and output

mapFolding/someAssemblyRequired/synthesizeNumbaJob.py

@@ -6,7 +6,7 @@ for specific map folding calculation jobs. Unlike the general-purpose transforma
 in toolboxNumba.py, this module creates standalone Python modules optimized for a
 single map shape with statically-encoded parameters.
 
-The code generation pipeline focuses on:
+The code generation assembly line focuses on:
 
 1. Converting function parameters to initialized variables with concrete values.
 2. Replacing dynamic computations with statically-known values.
@@ -18,7 +18,7 @@ This creates extremely fast, specialized implementations that can be run directl
 as Python scripts or further compiled into standalone executables.
 """
 
-from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal
+from mapFolding import getPathFilenameFoldsTotal, raiseIfNoneGitHubIssueNumber3, The
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
 	be,
@@ -29,15 +29,15 @@ from mapFolding.someAssemblyRequired import (
 	Make,
 	NodeChanger,
 	NodeTourist,
+	str_nameDOTname,
 	Then,
 )
-from mapFolding.someAssemblyRequired.toolboxNumba import parametersNumbaLight, SpicesJobNumba, decorateCallableWithNumba
-from mapFolding.someAssemblyRequired.transformationTools import extractFunctionDef, write_astModule, makeInitializedComputationState
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJob
-from mapFolding import The, raiseIfNoneGitHubIssueNumber3, getFoldsTotalKnown
-from typing import cast
-from Z0Z_tools import autoDecodingRLE
+from mapFolding.someAssemblyRequired.toolboxNumba import parametersNumbaLight, SpicesJobNumba, decorateCallableWithNumba
+from mapFolding.someAssemblyRequired.transformationTools import dictionaryEstimates, extractFunctionDef, write_astModule, makeInitializedComputationState
 from pathlib import PurePosixPath
+from typing import cast, NamedTuple
+from Z0Z_tools import autoDecodingRLE
 import ast
 """Synthesize one file to compute `foldsTotal` of `mapShape`."""
 
@@ -150,7 +150,7 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 					case 'scalar':
 						ImaAnnAssign.value.args[0].value = int(job.state.__dict__[ast_arg.arg]) # type: ignore
 					case 'array':
-						dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[ast_arg.arg], addSpaces=True)
+						dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[ast_arg.arg], True)
 						dataAs_astExpr: ast.expr = cast(ast.Expr, ast.parse(dataAsStrRLE).body[0]).value
 						ImaAnnAssign.value.args = [dataAs_astExpr] # type: ignore
 					case _:
@@ -175,7 +175,7 @@ def makeJobNumba(job: RecipeJob, spices: SpicesJobNumba) -> None:
 	"""
 	Generate a highly-optimized, single-purpose Numba module for a specific map shape.
 
-	This function implements the complete transformation pipeline for creating a
+	This function implements the complete transformation assembly line for creating a
 	standalone, specialized implementation for calculating map folding solutions for
 	a specific shape. The process includes:
 
@@ -228,9 +228,9 @@ if __name__ == '__main__':
 	writeStream = open('{job.pathFilenameFoldsTotal.as_posix()}', 'w')
 	writeStream.write(str(foldsTotal))
 	writeStream.close()
-	from mapFolding.oeis import getFoldsTotalKnown
-	print(foldsTotal == getFoldsTotalKnown({job.state.mapShape}))
 """
+	# from mapFolding.oeis import getFoldsTotalKnown
+	# print(foldsTotal == getFoldsTotalKnown({job.state.mapShape}))
 		ingredientsModule.appendLauncher(ast.parse(linesLaunch))
 		changeReturnParallelCallable = NodeChanger(be.Return, Then.replaceWith(Make.Return(job.shatteredDataclass.countingVariableName)))
 		changeReturnParallelCallable.visit(ingredientsCount.astFunctionDef)
@@ -238,38 +238,37 @@ if __name__ == '__main__':
 
 	ingredientsCount = move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsCount, job)
 
-	Z0Z_Identifier = 'DatatypeLeavesTotal'
-	Z0Z_type = 'uint8'
-	ingredientsModule.imports.addImportFrom_asStr('numba', Z0Z_type)
-	Z0Z_statement = Make.Assign([Make.Name(Z0Z_Identifier, ast.Store())], Make.Name(Z0Z_type))
-	ingredientsModule.appendPrologue(statement=Z0Z_statement)
+	class DatatypeConfig(NamedTuple):
+		Z0Z_module: str_nameDOTname
+		fml: ast_Identifier
+		Z0Z_type_name: ast_Identifier
+		Z0Z_asname: ast_Identifier | None = None
+
+	listDatatypeConfigs = [
+		DatatypeConfig(fml='DatatypeLeavesTotal', Z0Z_module='numba', Z0Z_type_name='uint8'),
+		DatatypeConfig(fml='DatatypeElephino', Z0Z_module='numba', Z0Z_type_name='uint16'),
+		DatatypeConfig(fml='DatatypeFoldsTotal', Z0Z_module='numba', Z0Z_type_name='uint64'),
+	]
+
+	for datatypeConfig in listDatatypeConfigs:
+		ingredientsModule.imports.addImportFrom_asStr(datatypeConfig.Z0Z_module, datatypeConfig.Z0Z_type_name)
+		statement = Make.Assign(
+			[Make.Name(datatypeConfig.fml, ast.Store())],
+			Make.Name(datatypeConfig.Z0Z_type_name)
+		)
+		ingredientsModule.appendPrologue(statement=statement)
 
-	Z0Z_Identifier = 'DatatypeElephino'
-	Z0Z_type = 'uint8'
-	ingredientsModule.imports.addImportFrom_asStr('numba', Z0Z_type)
-	Z0Z_statement = Make.Assign([Make.Name(Z0Z_Identifier, ast.Store())], Make.Name(Z0Z_type))
-	ingredientsModule.appendPrologue(statement=Z0Z_statement)
+	ingredientsCount.imports.removeImportFromModule('mapFolding.theSSOT')
 
-	Z0Z_Identifier = 'DatatypeFoldsTotal'
-	Z0Z_type = 'int64'
-	ingredientsModule.imports.addImportFrom_asStr('numba', Z0Z_type)
-	Z0Z_statement = Make.Assign([Make.Name(Z0Z_Identifier, ast.Store())], Make.Name(Z0Z_type))
-	ingredientsModule.appendPrologue(statement=Z0Z_statement)
+	listNumPyTypeConfigs = [
+		DatatypeConfig(fml='Array1DLeavesTotal', Z0Z_module='numpy', Z0Z_type_name='uint8', Z0Z_asname='Array1DLeavesTotal'),
+		DatatypeConfig(fml='Array1DElephino', Z0Z_module='numpy', Z0Z_type_name='uint16', Z0Z_asname='Array1DElephino'),
+		DatatypeConfig(fml='Array3D', Z0Z_module='numpy', Z0Z_type_name='uint8', Z0Z_asname='Array3D'),
+	]
 
-	ingredientsCount.imports.removeImportFromModule('mapFolding.theSSOT')
-	Z0Z_module = 'numpy'
-	Z0Z_asname = 'Array1DLeavesTotal'
-	ingredientsCount.imports.removeImportFrom(Z0Z_module, None, Z0Z_asname)
-	Z0Z_type_name = 'uint8'
-	ingredientsCount.imports.addImportFrom_asStr(Z0Z_module, Z0Z_type_name, Z0Z_asname)
-	Z0Z_asname = 'Array1DElephino'
-	ingredientsCount.imports.removeImportFrom(Z0Z_module, None, Z0Z_asname)
-	Z0Z_type_name = 'uint8'
-	ingredientsCount.imports.addImportFrom_asStr(Z0Z_module, Z0Z_type_name, Z0Z_asname)
-	Z0Z_asname = 'Array3D'
-	ingredientsCount.imports.removeImportFrom(Z0Z_module, None, Z0Z_asname)
-	Z0Z_type_name = 'uint8'
-	ingredientsCount.imports.addImportFrom_asStr(Z0Z_module, Z0Z_type_name, Z0Z_asname)
+	for typeConfig in listNumPyTypeConfigs:
+		ingredientsCount.imports.removeImportFrom(typeConfig.Z0Z_module, None, typeConfig.fml)
+		ingredientsCount.imports.addImportFrom_asStr(typeConfig.Z0Z_module, typeConfig.Z0Z_type_name, typeConfig.Z0Z_asname)
 
 	ingredientsCount.astFunctionDef.decorator_list = [] # TODO low-priority, handle this more elegantly
 	# TODO when I add the function signature in numba style back to the decorator, the logic needs to handle `ProgressBarType:`
@@ -300,9 +299,10 @@ if __name__ == '__main__':
 	"""
 
 if __name__ == '__main__':
-	mapShape = (1,24)
+	mapShape = (2,21)
 	state = makeInitializedComputationState(mapShape)
-	foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal
+	# foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal
+	foldsTotalEstimated = dictionaryEstimates[state.mapShape] // state.leavesTotal
 	pathModule = PurePosixPath(The.pathPackage, 'jobs')
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
 	aJob = RecipeJob(state, foldsTotalEstimated, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)

mapFolding/someAssemblyRequired/toolboxNumba.py

@@ -16,8 +16,8 @@ performance improvements while preserving code semantics and correctness.
 """
 
 from collections.abc import Callable, Sequence
-from mapFolding.someAssemblyRequired import Make, NodeTourist, RecipeSynthesizeFlow, Then, ast_Identifier, str_nameDOTname, IngredientsFunction
-from mapFolding.someAssemblyRequired.transformationTools import ( makeNewFlow, write_astModule, )
+from mapFolding.someAssemblyRequired import ast_Identifier, be, IngredientsFunction, Make, NodeTourist, RecipeSynthesizeFlow, str_nameDOTname, Then
+from mapFolding.someAssemblyRequired.transformationTools import makeNewFlow, write_astModule
 from numba.core.compiler import CompilerBase as numbaCompilerBase
 from typing import Any, cast, Final, TYPE_CHECKING, TypeGuard
 import ast
@@ -154,19 +154,11 @@ class SpicesJobNumba:
 	parametersNumba: ParametersNumba = dataclasses.field(default_factory=ParametersNumba) # type: ignore
 
 # Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
-class be:
-	@staticmethod
-	def Call(node: ast.AST) -> TypeGuard[ast.Call]:
-		return isinstance(node, ast.Call)
-	@staticmethod
-	def Return(node: ast.AST) -> TypeGuard[ast.Return]:
-		return isinstance(node, ast.Return)
-
 def makeNumbaFlow(numbaFlow: RecipeSynthesizeFlow) -> None:
 	"""
 	Transform standard Python algorithm code into optimized Numba implementations.
 
-	This function implements the complete transformation pipeline that converts
+	This function implements the complete transformation assembly line that converts
 	a conventional Python implementation into a high-performance Numba-accelerated
 	version. The process includes: