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

mapFolding/someAssemblyRequired/__init__.py

@@ -1,50 +1,47 @@
 """
 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 (
@@ -85,6 +82,7 @@ from mapFolding.someAssemblyRequired._tool_Make import Make as Make
 from mapFolding.someAssemblyRequired._tool_Then import grab as grab, Then as Then
 
 from mapFolding.someAssemblyRequired._toolboxContainers import (
+	DeReConstructField2ast as DeReConstructField2ast,
 	IngredientsFunction as IngredientsFunction,
 	IngredientsModule as IngredientsModule,
 	LedgerOfImports as LedgerOfImports,

mapFolding/someAssemblyRequired/_theTypes.py

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

mapFolding/someAssemblyRequired/_tool_Make.py

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

mapFolding/someAssemblyRequired/_tool_Then.py

@@ -1,36 +1,32 @@
 """
 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
 from mapFolding.someAssemblyRequired import ast_Identifier, astClassHasDOTvalue, ImaCallToName, NodeORattribute
-from typing import Any, overload
+from typing import Any
 import ast
 
 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]:
@@ -114,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/_toolboxAntecedents.py

@@ -28,12 +28,12 @@ from mapFolding.someAssemblyRequired import (
 	astClassHasDOTnameNotName,
 	astClassHasDOTnameNotNameAlways,
 	astClassHasDOTnameNotNameOptionally,
-	astClassHasDOTtarget_expr,
 	astClassHasDOTtarget,
+	astClassHasDOTtarget_expr,
 	astClassHasDOTtargetAttributeNameSubscript,
+	astClassHasDOTvalue,
 	astClassHasDOTvalue_expr,
 	astClassHasDOTvalue_exprNone,
-	astClassHasDOTvalue,
 	ImaCallToName,
 )
 from typing import Any, overload, TypeGuard
@@ -43,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
@@ -213,6 +212,10 @@ class be:
 	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)
@@ -229,6 +232,10 @@ class be:
 	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)
@@ -237,13 +244,12 @@ 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]:
@@ -304,7 +310,18 @@ class ifThis:
 					and ifThis.isConstant_value(0)(node.comparators[0]))
 
 	@staticmethod
-	def isIfAttributeNamespace_IdentifierGreaterThan0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.While] | bool]:
+	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))
 

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
@@ -171,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`.
@@ -311,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
@@ -471,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]