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

mapFolding/someAssemblyRequired/_tool_Then.py

@@ -1,17 +1,15 @@
 """
 AST Node Transformation Actions for Python Code Manipulation
 
-This module provides the Then class with static methods for generating callable
-action functions that specify what to do with AST nodes that match predicates.
-These action functions are used primarily with NodeChanger and NodeTourist to
+This module provides the Then class with static methods for generating callable action functions that specify what to do
+with AST nodes that match predicates. These action functions are used primarily with NodeChanger and NodeTourist to
 transform or extract information from AST nodes.
 
-The module also contains the grab class that provides functions for modifying
-specific attributes of AST nodes while preserving their structure, enabling
-fine-grained control when transforming AST structures.
+The module also contains the grab class that provides functions for modifying specific attributes of AST nodes while
+preserving their structure, enabling fine-grained control when transforming AST structures.
 
-Together, these classes provide a complete system for manipulating AST nodes
-once they have been identified using predicate functions from ifThis.
+Together, these classes provide a complete system for manipulating AST nodes once they have been identified using
+predicate functions from ifThis.
 """
 
 from collections.abc import Callable, Sequence
@@ -23,15 +21,21 @@ class grab:
 	"""
 	Modify specific attributes of AST nodes while preserving the node structure.
 
-	The grab class provides static methods that create transformation functions to modify
-	specific attributes of AST nodes. Unlike DOT which provides read-only access,
-	grab allows for targeted modifications of node attributes without replacing the
-	entire node.
+	The grab class provides static methods that create transformation functions to modify specific attributes of AST
+	nodes. Unlike DOT which provides read-only access, grab allows for targeted modifications of node attributes without
+	replacing the entire node.
 
-	Each method returns a function that takes a node, applies a transformation to a
-	specific attribute of that node, and returns the modified node. This enables fine-grained
-	control when transforming AST structures.
+	Each method returns a function that takes a node, applies a transformation to a specific attribute of that node, and
+	returns the modified node. This enables fine-grained control when transforming AST structures.
 	"""
+	@staticmethod
+	def andDoAllOf(listOfActions: list[Callable[[NodeORattribute], NodeORattribute]]) -> Callable[[NodeORattribute], NodeORattribute]:
+		def workhorse(node: NodeORattribute) -> NodeORattribute:
+			for action in listOfActions:
+				node = action(node)
+			return node
+		return workhorse
+
 	@staticmethod
 	def argAttribute(action: Callable[[ast_Identifier | None], ast_Identifier]) -> Callable[[ast.arg | ast.keyword], ast.arg | ast.keyword]:
 		def workhorse(node: ast.arg | ast.keyword) -> ast.arg | ast.keyword:
@@ -39,6 +43,20 @@ class grab:
 			return node
 		return workhorse
 
+	@staticmethod
+	def attrAttribute(action: Callable[[ast_Identifier], ast_Identifier]) -> Callable[[ast.Attribute], ast.Attribute]:
+		def workhorse(node: ast.Attribute) -> ast.Attribute:
+			node.attr = action(node.attr)
+			return node
+		return workhorse
+
+	@staticmethod
+	def comparatorsAttribute(action: Callable[[list[ast.expr]], list[ast.expr]]) -> Callable[[ast.Compare], ast.Compare]:
+		def workhorse(node: ast.Compare) -> ast.Compare:
+			node.comparators = action(node.comparators)
+			return node
+		return workhorse
+
 	@staticmethod
 	def funcAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[ast.Call], ast.Call]:
 		def workhorse(node: ast.Call) -> ast.Call:
@@ -60,6 +78,27 @@ class grab:
 			return node
 		return workhorse
 
+	@staticmethod
+	def leftAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[ast.BinOp | ast.Compare], ast.BinOp | ast.Compare]:
+		def workhorse(node: ast.BinOp | ast.Compare) -> ast.BinOp | ast.Compare:
+			node.left = action(node.left)
+			return node
+		return workhorse
+
+	@staticmethod
+	def opsAttribute(action: Callable[[list[ast.cmpop]], list[ast.cmpop]]) -> Callable[[ast.Compare], ast.Compare]:
+		def workhorse(node: ast.Compare) -> ast.Compare:
+			node.ops = action(node.ops)
+			return node
+		return workhorse
+
+	@staticmethod
+	def testAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[ast.Assert | ast.If | ast.IfExp | ast.While], ast.Assert | ast.If | ast.IfExp | ast.While]:
+		def workhorse(node: ast.Assert | ast.If | ast.IfExp | ast.While) -> ast.Assert | ast.If | ast.IfExp | ast.While:
+			node.test = action(node.test)
+			return node
+		return workhorse
+
 	@staticmethod
 	def valueAttribute(action: Callable[[Any], Any]) -> Callable[[astClassHasDOTvalue], astClassHasDOTvalue]:
 		def workhorse(node: astClassHasDOTvalue) -> astClassHasDOTvalue:
@@ -71,13 +110,12 @@ class Then:
 	"""
 	Provide action functions that specify what to do with AST nodes that match predicates.
 
-	The Then class contains static methods that generate action functions used with
-	NodeChanger and NodeTourist to transform or extract information from AST nodes
-	that match specific predicates. These actions include node replacement, insertion,
-	extraction, and collection operations.
+	The Then class contains static methods that generate action functions used with NodeChanger and NodeTourist to
+	transform or extract information from AST nodes that match specific predicates. These actions include node
+	replacement, insertion, extraction, and collection operations.
 
-	When paired with predicates from the ifThis class, Then methods complete the
-	pattern-matching-and-action workflow for AST manipulation.
+	When paired with predicates from the ifThis class, Then methods complete the pattern-matching-and-action workflow
+	for AST manipulation.
 	"""
 	@staticmethod
 	def appendTo(listOfAny: list[Any]) -> Callable[[ast.AST | ast_Identifier], ast.AST | ast_Identifier]:

mapFolding/someAssemblyRequired/_toolboxAST.py

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

mapFolding/someAssemblyRequired/_toolboxAntecedents.py

@@ -1,35 +1,38 @@
 """
 AST Node Predicate and Access Utilities for Pattern Matching and Traversal
 
-This module provides utilities for accessing and matching AST nodes in a consistent way.
-It contains three primary classes:
+This module provides utilities for accessing and matching AST nodes in a consistent way. It contains three primary
+classes:
 
-1. DOT: Provides consistent accessor methods for AST node attributes across different
-   node types, simplifying the access to node properties.
+1. DOT: Provides consistent accessor methods for AST node attributes across different node types, simplifying the access
+	to node properties.
 
-2. be: Offers type-guard functions that verify AST node types, enabling safe type
-   narrowing for static type checking and improving code safety.
+2. be: Offers type-guard functions that verify AST node types, enabling safe type narrowing for static type checking and
+	improving code safety.
 
-3. ifThis: Contains predicate functions for matching AST nodes based on various criteria,
-   enabling precise targeting of nodes for analysis or transformation.
+3. ifThis: Contains predicate functions for matching AST nodes based on various criteria, enabling precise targeting of
+	nodes for analysis or transformation.
 
-These utilities form the foundation of the pattern-matching component in the AST
-manipulation framework, working in conjunction with the NodeChanger and NodeTourist
-classes to enable precise and targeted code transformations. Together, they implement
-a declarative approach to AST manipulation that separates node identification (ifThis),
-type verification (be), and data access (DOT).
+These utilities form the foundation of the pattern-matching component in the AST manipulation framework, working in
+conjunction with the NodeChanger and NodeTourist classes to enable precise and targeted code transformations. Together,
+they implement a declarative approach to AST manipulation that separates node identification (ifThis), type verification
+(be), and data access (DOT).
 """
 
 from collections.abc import Callable
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
+	astClassHasDOTbody,
+	astClassHasDOTbody_expr,
+	astClassHasDOTbodyList_stmt,
 	astClassHasDOTnameNotName,
+	astClassHasDOTnameNotNameAlways,
+	astClassHasDOTnameNotNameOptionally,
 	astClassHasDOTtarget,
-	astClassHasDOTtargetAttributeNameSubscript,
 	astClassHasDOTtarget_expr,
+	astClassHasDOTtargetAttributeNameSubscript,
 	astClassHasDOTvalue,
 	astClassHasDOTvalue_expr,
-	astClassOptionallyHasDOTnameNotName,
 	astClassHasDOTvalue_exprNone,
 	ImaCallToName,
 )
@@ -40,13 +43,12 @@ class DOT:
 	"""
 	Access attributes and sub-nodes of AST elements via consistent accessor methods.
 
-	The DOT class provides static methods to access specific attributes of different
-	types of AST nodes in a consistent way. This simplifies attribute access across
-	various node types and improves code readability by abstracting the underlying
-	AST structure details.
+	The DOT class provides static methods to access specific attributes of different types of AST nodes in a consistent
+	way. This simplifies attribute access across various node types and improves code readability by abstracting the
+	underlying AST structure details.
 
-	DOT is designed for safe, read-only access to node properties, unlike the grab
-	class which is designed for modifying node attributes.
+	DOT is designed for safe, read-only access to node properties, unlike the grab class which is designed for modifying
+	node attributes.
 	"""
 	@staticmethod
 	@overload
@@ -72,6 +74,16 @@ class DOT:
 	def attr(node: ast.Attribute) -> ast_Identifier:
 		return node.attr
 
+	@staticmethod
+	@overload
+	def body(node: astClassHasDOTbodyList_stmt) -> list[ast.stmt]:...
+	@staticmethod
+	@overload
+	def body(node: astClassHasDOTbody_expr) -> ast.expr:...
+	@staticmethod
+	def body(node: astClassHasDOTbody) -> ast.expr | list[ast.stmt]:
+		return node.body
+
 	@staticmethod
 	@overload
 	def func(node: ImaCallToName) -> ast.Name:...
@@ -88,12 +100,12 @@ class DOT:
 
 	@staticmethod
 	@overload
-	def name(node: astClassHasDOTnameNotName) -> ast_Identifier:...
+	def name(node: astClassHasDOTnameNotNameAlways) -> ast_Identifier:...
 	@staticmethod
 	@overload
-	def name(node: astClassOptionallyHasDOTnameNotName) -> ast_Identifier | None:...
+	def name(node: astClassHasDOTnameNotNameOptionally) -> ast_Identifier | None:...
 	@staticmethod
-	def name(node: astClassHasDOTnameNotName | astClassOptionallyHasDOTnameNotName) -> ast_Identifier | None:
+	def name(node: astClassHasDOTnameNotName) -> ast_Identifier | None:
 		return node.name
 
 	@staticmethod
@@ -129,18 +141,16 @@ class be:
 	"""
 	Provide type-guard functions for safely verifying AST node types during manipulation.
 
-	The be class contains static methods that perform runtime type verification of AST nodes,
-	returning TypeGuard results that enable static type checkers to narrow node types in
-	conditional branches. These type-guards:
+	The be class contains static methods that perform runtime type verification of AST nodes, returning TypeGuard
+	results that enable static type checkers to narrow node types in conditional branches. These type-guards:
 
-	1. Improve code safety by preventing operations on incompatible node types
-	2. Enable IDE tooling to provide better autocompletion and error detection
-	3. Document expected node types in a way that's enforced by the type system
-	4. Support pattern-matching workflows where node types must be verified before access
+	1. Improve code safety by preventing operations on incompatible node types.
+	2. Enable IDE tooling to provide better autocompletion and error detection.
+	3. Document expected node types in a way that's enforced by the type system.
+	4. Support pattern-matching workflows where node types must be verified before access.
 
-	When used with conditional statements, these type-guards allow for precise,
-	type-safe manipulation of AST nodes while maintaining full static type checking
-	capabilities, even in complex transformation scenarios.
+	When used with conditional statements, these type-guards allow for precise, type-safe manipulation of AST nodes
+	while maintaining full static type checking capabilities, even in complex transformation scenarios.
 	"""
 	@staticmethod
 	def AnnAssign(node: ast.AST) -> TypeGuard[ast.AnnAssign]:
@@ -170,6 +180,14 @@ class be:
 	def ClassDef(node: ast.AST) -> TypeGuard[ast.ClassDef]:
 		return isinstance(node, ast.ClassDef)
 
+	@staticmethod
+	def Compare(node: ast.AST) -> TypeGuard[ast.Compare]:
+		return isinstance(node, ast.Compare)
+
+	@staticmethod
+	def Constant(node: ast.AST) -> TypeGuard[ast.Constant]:
+		return isinstance(node, ast.Constant)
+
 	@staticmethod
 	def FunctionDef(node: ast.AST) -> TypeGuard[ast.FunctionDef]:
 		return isinstance(node, ast.FunctionDef)
@@ -178,10 +196,26 @@ class be:
 	def keyword(node: ast.AST) -> TypeGuard[ast.keyword]:
 		return isinstance(node, ast.keyword)
 
+	@staticmethod
+	def If(node: ast.AST) -> TypeGuard[ast.If]:
+		return isinstance(node, ast.If)
+
+	@staticmethod
+	def Gt(node: ast.AST) -> TypeGuard[ast.Gt]:
+		return isinstance(node, ast.Gt)
+
+	@staticmethod
+	def LtE(node: ast.AST) -> TypeGuard[ast.LtE]:
+		return isinstance(node, ast.LtE)
+
 	@staticmethod
 	def Name(node: ast.AST) -> TypeGuard[ast.Name]:
 		return isinstance(node, ast.Name)
 
+	@staticmethod
+	def Not(node: ast.AST) -> TypeGuard[ast.Not]:
+		return isinstance(node, ast.Not)
+
 	@staticmethod
 	def Return(node: ast.AST) -> TypeGuard[ast.Return]:
 		return isinstance(node, ast.Return)
@@ -194,17 +228,28 @@ class be:
 	def Subscript(node: ast.AST) -> TypeGuard[ast.Subscript]:
 		return isinstance(node, ast.Subscript)
 
+	@staticmethod
+	def Tuple(node: ast.AST) -> TypeGuard[ast.Tuple]:
+		return isinstance(node, ast.Tuple)
+
+	@staticmethod
+	def UnaryOp(node: ast.AST) -> TypeGuard[ast.UnaryOp]:
+		return isinstance(node, ast.UnaryOp)
+
+	@staticmethod
+	def While(node: ast.AST) -> TypeGuard[ast.While]:
+		return isinstance(node, ast.While)
+
 class ifThis:
 	"""
 	Provide predicate functions for matching and filtering AST nodes based on various criteria.
 
-	The ifThis class contains static methods that generate predicate functions used to test
-	whether AST nodes match specific criteria. These predicates can be used with NodeChanger
-	and NodeTourist to identify and process specific patterns in the AST.
+	The ifThis class contains static methods that generate predicate functions used to test whether AST nodes match
+	specific criteria. These predicates can be used with NodeChanger and NodeTourist to identify and process specific
+	patterns in the AST.
 
-	The class provides predicates for matching various node types, attributes, identifiers,
-	and structural patterns, enabling precise targeting of AST elements for analysis or
-	transformation.
+	The class provides predicates for matching various node types, attributes, identifiers, and structural patterns,
+	enabling precise targeting of AST elements for analysis or transformation.
 	"""
 	@staticmethod
 	def _Identifier(identifier: ast_Identifier) -> Callable[[ast_Identifier | None], TypeGuard[ast_Identifier] | bool]:
@@ -257,6 +302,40 @@ class ifThis:
 	def isAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Attribute] | bool]:
 		return lambda node: ifThis.isAttributeName(node) and ifThis.isName_Identifier(namespace)(DOT.value(node)) and ifThis._Identifier(identifier)(DOT.attr(node))
 
+	@staticmethod
+	def isAttributeNamespace_IdentifierGreaterThan0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
+		return lambda node: (be.Compare(node)
+					and ifThis.isAttributeNamespace_Identifier(namespace, identifier)(node.left)
+					and be.Gt(node.ops[0])
+					and ifThis.isConstant_value(0)(node.comparators[0]))
+
+	@staticmethod
+	def isUnaryNotAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.UnaryOp] | bool]:
+		return lambda node: (be.UnaryOp(node)
+					and be.Not(node.op)
+					and ifThis.isAttributeNamespace_Identifier(namespace, identifier)(node.operand))
+
+	@staticmethod
+	def isIfUnaryNotAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.If] | bool]:
+		return lambda node: (be.If(node)
+					and ifThis.isUnaryNotAttributeNamespace_Identifier(namespace, identifier)(node.test))
+
+	@staticmethod
+	def isIfAttributeNamespace_IdentifierGreaterThan0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.If] | bool]:
+		return lambda node: (be.If(node)
+					and ifThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(node.test))
+
+	@staticmethod
+	def isWhileAttributeNamespace_IdentifierGreaterThan0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.While] | bool]:
+		return lambda node: (be.While(node)
+					and ifThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(node.test))
+
+	@staticmethod
+	def isAttributeNamespace_IdentifierLessThanOrEqual(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
+		return lambda node: (be.Compare(node)
+					and ifThis.isAttributeNamespace_Identifier(namespace, identifier)(node.left)
+					and be.LtE(node.ops[0]))
+
 	@staticmethod
 	def isAugAssign_targetIs(targetPredicate: Callable[[ast.expr], TypeGuard[ast.expr] | bool]) -> Callable[[ast.AST], TypeGuard[ast.AugAssign] | bool]:
 		def workhorse(node: ast.AST) -> TypeGuard[ast.AugAssign] | bool:
@@ -282,6 +361,10 @@ class ifThis:
 	def isClassDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.ClassDef] | bool]:
 		return lambda node: be.ClassDef(node) and ifThis._Identifier(identifier)(DOT.name(node))
 
+	@staticmethod
+	def isConstant_value(value: Any) -> Callable[[ast.AST], TypeGuard[ast.Constant] | bool]:
+		return lambda node: be.Constant(node) and DOT.value(node) == value
+
 	@staticmethod
 	def isFunctionDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.FunctionDef] | bool]:
 		return lambda node: be.FunctionDef(node) and ifThis._Identifier(identifier)(DOT.name(node))

mapFolding/someAssemblyRequired/_toolboxContainers.py

@@ -19,9 +19,11 @@ specific optimizations and transformations.
 """
 
 from collections import defaultdict
-from collections.abc import Sequence
-from mapFolding.someAssemblyRequired import ast_Identifier, Make, parseLogicalPath2astModule, str_nameDOTname
-from mapFolding.theSSOT import The
+from collections.abc import Callable, Sequence
+from copy import deepcopy
+from typing import Any
+from mapFolding.someAssemblyRequired import ast_Identifier, DOT, ifThis, Make, NodeTourist, parseLogicalPath2astModule, str_nameDOTname, Then
+from mapFolding.theSSOT import raiseIfNoneGitHubIssueNumber3, The
 from pathlib import Path, PurePosixPath
 from Z0Z_tools import updateExtendPolishDictionaryLists
 import ast
@@ -32,8 +34,7 @@ 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.
-	It enables:
+	structure of imports and their textual representation. It enables:
 
 	1. Tracking regular imports and import-from statements.
 	2. Adding imports programmatically during code transformation.
@@ -46,8 +47,6 @@ class LedgerOfImports:
 	"""
 	# TODO When resolving the ledger of imports, remove self-referential imports
 
-	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] = []
@@ -77,8 +76,6 @@ class LedgerOfImports:
 			self.type_ignores.extend(type_ignores)
 
 	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)
@@ -131,7 +128,8 @@ class LedgerOfImports:
 		Parameters:
 			*fromLedger: One or more other `LedgerOfImports` objects from which to merge.
 		"""
-		self.dictionaryImportFrom = updateExtendPolishDictionaryLists(self.dictionaryImportFrom, *(ledger.dictionaryImportFrom for ledger in fromLedger), destroyDuplicates=True, reorderLists=True)
+		updatedDictionary = updateExtendPolishDictionaryLists(self.dictionaryImportFrom, *(ledger.dictionaryImportFrom for ledger in fromLedger), destroyDuplicates=True, reorderLists=True)
+		self.dictionaryImportFrom = defaultdict(list, updatedDictionary)
 		for ledger in fromLedger:
 			self.listImport.extend(ledger.listImport)
 			self.type_ignores.extend(ledger.type_ignores)
@@ -175,22 +173,21 @@ class IngredientsModule:
 	"""
 	Assemble a complete Python module from its constituent AST components.
 
-	IngredientsModule provides a structured container for all elements needed to
-	generate a complete Python module, including:
+	IngredientsModule provides a structured container for all elements needed to generate a complete Python module,
+	including:
 
-	1. Import statements aggregated from all module components
-	2. Prologue code that runs before function definitions
-	3. Function definitions with their dependencies
-	4. Epilogue code that runs after function definitions
-	5. Entry point code executed when the module runs as a script
-	6. Type ignores and other annotations
+	1. Import statements aggregated from all module components.
+	2. Prologue code that runs before function definitions.
+	3. Function definitions with their dependencies.
+	4. Epilogue code that runs after function definitions.
+	5. Entry point code executed when the module runs as a script.
+	6. Type ignores and other annotations.
 
-	This class enables programmatic assembly of Python modules with a clear
-	separation between different structural elements, while maintaining the
-	proper ordering and relationships between components.
+	This class enables programmatic assembly of Python modules with a clear separation between different structural
+	elements, while maintaining the proper ordering and relationships between components.
 
-	The modular design allows transformations to be applied to specific parts
-	of a module while preserving the overall structure.
+	The modular design allows transformations to be applied to specific parts of a module while preserving the overall
+	structure.
 
 	Parameters:
 		ingredientsFunction (None): One or more `IngredientsFunction` that will appended to `listIngredientsFunctions`.
@@ -315,22 +312,20 @@ class RecipeSynthesizeFlow:
 	"""
 	Configure the generation of new modules, including Numba-accelerated code modules.
 
-	RecipeSynthesizeFlow defines the complete blueprint for transforming an original
-	Python algorithm into an optimized, accelerated implementation. It specifies:
+	RecipeSynthesizeFlow defines the complete blueprint for transforming an original Python algorithm into an optimized,
+	accelerated implementation. It specifies:
 
-	1. Source code locations and identifiers
-	2. Target code locations and identifiers
-	3. Naming conventions for generated modules and functions
-	4. File system paths for output files
-	5. Import relationships between components
+	1. Source code locations and identifiers.
+	2. Target code locations and identifiers.
+	3. Naming conventions for generated modules and functions.
+	4. File system paths for output files.
+	5. Import relationships between components.
 
-	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 assembly line.
+	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 assembly line.
 
-	The transformation process uses this configuration to extract functions from the
-	source module, transform them according to optimization rules, and output
-	properly structured optimized modules with all necessary imports.
+	The transformation process uses this configuration to extract functions from the source module, transform them
+	according to optimization rules, and output properly structured optimized modules with all necessary imports.
 	"""
 	# ========================================
 	# Source
@@ -449,7 +444,7 @@ class ShatteredDataclass:
 	fragments4AssignmentOrParameters: ast.Tuple = dummyTuple
 	"""AST tuple used as target for assignment to capture returned fragments."""
 
-	ledger: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
+	imports: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
 	"""Import records for the dataclass and its constituent parts."""
 
 	list_argAnnotated4ArgumentsSpecification: list[ast.arg] = dataclasses.field(default_factory=list)
@@ -475,3 +470,99 @@ class ShatteredDataclass:
 
 	signatureReturnAnnotation: ast.Subscript = dummySubscript
 	"""tuple-based return type annotation for function definitions."""
+
+@dataclasses.dataclass
+class DeReConstructField2ast:
+	"""
+	Transform a dataclass field into AST node representations for code generation.
+
+	This class extracts and transforms a dataclass Field object into various AST node
+	representations needed for code generation. It handles the conversion of field
+	attributes, type annotations, and metadata into AST constructs that can be used
+	to reconstruct the field in generated code.
+
+	The class is particularly important for decomposing dataclass fields (like those in
+	ComputationState) to enable their use in specialized contexts like Numba-optimized
+	functions, where the full dataclass cannot be directly used but its contents need
+	to be accessible.
+
+	Each field is processed according to its type and metadata to create appropriate
+	variable declarations, type annotations, and initialization code as AST nodes.
+	"""
+	dataclassesDOTdataclassLogicalPathModule: dataclasses.InitVar[str_nameDOTname]
+	dataclassClassDef: dataclasses.InitVar[ast.ClassDef]
+	dataclassesDOTdataclassInstance_Identifier: dataclasses.InitVar[ast_Identifier]
+	field: dataclasses.InitVar[dataclasses.Field[Any]]
+
+	ledger: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
+
+	name: ast_Identifier = dataclasses.field(init=False)
+	typeBuffalo: type[Any] | str | Any = dataclasses.field(init=False)
+	default: Any | None = dataclasses.field(init=False)
+	default_factory: Callable[..., Any] | None = dataclasses.field(init=False)
+	repr: bool = dataclasses.field(init=False)
+	hash: bool | None = dataclasses.field(init=False)
+	init: bool = dataclasses.field(init=False)
+	compare: bool = dataclasses.field(init=False)
+	metadata: dict[Any, Any] = dataclasses.field(init=False)
+	kw_only: bool = dataclasses.field(init=False)
+
+	astName: ast.Name = dataclasses.field(init=False)
+	ast_keyword_field__field: ast.keyword = dataclasses.field(init=False)
+	ast_nameDOTname: ast.Attribute = dataclasses.field(init=False)
+	astAnnotation: ast.expr = dataclasses.field(init=False)
+	ast_argAnnotated: ast.arg = dataclasses.field(init=False)
+	astAnnAssignConstructor: ast.AnnAssign|ast.Assign = dataclasses.field(init=False)
+	Z0Z_hack: tuple[ast.AnnAssign|ast.Assign, str] = dataclasses.field(init=False)
+
+	def __post_init__(self, dataclassesDOTdataclassLogicalPathModule: str_nameDOTname, dataclassClassDef: ast.ClassDef, dataclassesDOTdataclassInstance_Identifier: ast_Identifier, field: dataclasses.Field[Any]) -> None:
+		self.compare = field.compare
+		self.default = field.default if field.default is not dataclasses.MISSING else None
+		self.default_factory = field.default_factory if field.default_factory is not dataclasses.MISSING else None
+		self.hash = field.hash
+		self.init = field.init
+		self.kw_only = field.kw_only if field.kw_only is not dataclasses.MISSING else False
+		self.metadata = dict(field.metadata)
+		self.name = field.name
+		self.repr = field.repr
+		self.typeBuffalo = field.type
+
+		self.astName = Make.Name(self.name)
+		self.ast_keyword_field__field = Make.keyword(self.name, self.astName)
+		self.ast_nameDOTname = Make.Attribute(Make.Name(dataclassesDOTdataclassInstance_Identifier), self.name)
+
+		sherpa = NodeTourist(ifThis.isAnnAssign_targetIs(ifThis.isName_Identifier(self.name)), Then.extractIt(DOT.annotation)).captureLastMatch(dataclassClassDef)
+		if sherpa is None: raise raiseIfNoneGitHubIssueNumber3
+		else: self.astAnnotation = sherpa
+
+		self.ast_argAnnotated = Make.arg(self.name, self.astAnnotation)
+
+		dtype = self.metadata.get('dtype', None)
+		if dtype:
+			moduleWithLogicalPath: str_nameDOTname = 'numpy'
+			annotationType = 'ndarray'
+			self.ledger.addImportFrom_asStr(moduleWithLogicalPath, annotationType)
+			self.ledger.addImportFrom_asStr(moduleWithLogicalPath, 'dtype')
+			axesSubscript = Make.Subscript(Make.Name('tuple'), Make.Name('uint8'))
+			dtype_asnameName: ast.Name = self.astAnnotation # type: ignore
+			if dtype_asnameName.id == 'Array3D':
+				axesSubscript = Make.Subscript(Make.Name('tuple'), Make.Tuple([Make.Name('uint8'), Make.Name('uint8'), Make.Name('uint8')]))
+			ast_expr = Make.Subscript(Make.Name(annotationType), Make.Tuple([axesSubscript, Make.Subscript(Make.Name('dtype'), dtype_asnameName)]))
+			constructor = 'array'
+			self.ledger.addImportFrom_asStr(moduleWithLogicalPath, constructor)
+			dtypeIdentifier: ast_Identifier = dtype.__name__
+			self.ledger.addImportFrom_asStr(moduleWithLogicalPath, dtypeIdentifier, dtype_asnameName.id)
+			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, ast_expr, Make.Call(Make.Name(constructor), list_astKeywords=[Make.keyword('dtype', dtype_asnameName)]))
+			self.astAnnAssignConstructor = Make.Assign([self.astName], Make.Call(Make.Name(constructor), list_astKeywords=[Make.keyword('dtype', dtype_asnameName)]))
+			self.Z0Z_hack = (self.astAnnAssignConstructor, 'array')
+		elif isinstance(self.astAnnotation, ast.Name):
+			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, Make.Call(self.astAnnotation, [Make.Constant(-1)]))
+			self.Z0Z_hack = (self.astAnnAssignConstructor, 'scalar')
+		elif isinstance(self.astAnnotation, ast.Subscript):
+			elementConstructor: ast_Identifier = self.metadata['elementConstructor']
+			self.ledger.addImportFrom_asStr(dataclassesDOTdataclassLogicalPathModule, elementConstructor)
+			takeTheTuple: ast.Tuple = deepcopy(self.astAnnotation.slice) # type: ignore
+			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, takeTheTuple)
+			self.Z0Z_hack = (self.astAnnAssignConstructor, elementConstructor)
+		if isinstance(self.astAnnotation, ast.Name):
+			self.ledger.addImportFrom_asStr(dataclassesDOTdataclassLogicalPathModule, self.astAnnotation.id) # pyright: ignore [reportUnknownArgumentType, reportUnknownMemberType, reportIJustCalledATypeGuardMethod_WTF]