mapFolding 0.10.0__tar.gz → 0.11.1__tar.gz

{mapfolding-0.10.0 → mapfolding-0.11.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.10.0
+Version: 0.11.1
 Summary: Map folding algorithm with code transformation framework for optimizing numerical computations
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -31,6 +31,7 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: astToolkit
 Requires-Dist: autoflake
 Requires-Dist: cytoolz
 Requires-Dist: more_itertools

{mapfolding-0.10.0 → mapfolding-0.11.1}/mapFolding/__init__.py

@@ -47,38 +47,22 @@ foundation for exploring advanced code transformation techniques.
 from typing import Any, TypeAlias
 import sys
 
-stuPyd: TypeAlias = Any
-
-if sys.version_info >= (3, 12):
-	from ast import (
-		ParamSpec as astDOTParamSpec,
-		type_param as astDOTtype_param,
-		TypeAlias as astDOTTypeAlias,
-		TypeVar as astDOTTypeVar,
-		TypeVarTuple as astDOTTypeVarTuple,
-	)
-else:
-	astDOTParamSpec: TypeAlias = stuPyd
-	astDOTtype_param: TypeAlias = stuPyd
-	astDOTTypeAlias: TypeAlias = stuPyd
-	astDOTTypeVar: TypeAlias = stuPyd
-	astDOTTypeVarTuple: TypeAlias = stuPyd
+yourPythonIsOld: TypeAlias = Any
+# ruff: noqa: E402
 
 if sys.version_info >= (3, 11):
-	from ast import TryStar as astDOTTryStar
 	from typing import TypedDict as TypedDict
 	from typing import NotRequired as NotRequired
 else:
-	astDOTTryStar: TypeAlias = stuPyd
 	try:
 		from typing_extensions import TypedDict as TypedDict
 		from typing_extensions import NotRequired as NotRequired
 	except Exception:
-		TypedDict = dict[stuPyd, stuPyd]
+		TypedDict = dict[yourPythonIsOld, yourPythonIsOld]
 		from collections.abc import Iterable
 		NotRequired: TypeAlias = Iterable
 
-from mapFolding.datatypes import (  # noqa: E402
+from mapFolding.datatypes import (
 	Array1DElephino as Array1DElephino,
 	Array1DFoldsTotal as Array1DFoldsTotal,
 	Array1DLeavesTotal as Array1DLeavesTotal,
@@ -92,18 +76,18 @@ from mapFolding.datatypes import (  # noqa: E402
 	NumPyLeavesTotal as NumPyLeavesTotal,
 )
 
-from mapFolding.theSSOT import (  # noqa: E402
+from mapFolding.theSSOT import (
 	ComputationState as ComputationState,
 	raiseIfNoneGitHubIssueNumber3 as raiseIfNoneGitHubIssueNumber3,
 	The as The,
 )
 
-from mapFolding.theDao import (  # noqa: E402
+from mapFolding.theDao import (
 	countInitialize as countInitialize,
 	doTheNeedful as doTheNeedful,
 )
 
-from mapFolding.beDRY import (  # noqa: E402
+from mapFolding.beDRY import (
 	getLeavesTotal as getLeavesTotal,
 	getTaskDivisions as getTaskDivisions,
 	outfitCountFolds as outfitCountFolds,
@@ -111,17 +95,18 @@ from mapFolding.beDRY import (  # noqa: E402
 	validateListDimensions as validateListDimensions,
 )
 
-from mapFolding.toolboxFilesystem import (  # noqa: E402
+from mapFolding.toolboxFilesystem import (
 	getPathFilenameFoldsTotal as getPathFilenameFoldsTotal,
 	getPathRootJobDEFAULT as getPathRootJobDEFAULT,
 	saveFoldsTotal as saveFoldsTotal,
 	saveFoldsTotalFAILearly as saveFoldsTotalFAILearly,
-	writeStringToHere as writeStringToHere,
 )
 
-from mapFolding.basecamp import countFolds as countFolds  # noqa: E402
+from Z0Z_tools import writeStringToHere as writeStringToHere
+
+from mapFolding.basecamp import countFolds as countFolds
 
-from mapFolding.oeis import (  # noqa: E402
+from mapFolding.oeis import (
 	clearOEIScache as clearOEIScache,
 	getFoldsTotalKnown as getFoldsTotalKnown,
 	getOEISids as getOEISids,

{mapfolding-0.10.0 → mapfolding-0.11.1}/mapFolding/someAssemblyRequired/Z0Z_makeSomeModules.py

@@ -9,24 +9,24 @@ from mapFolding.someAssemblyRequired import (
 	IfThis,
 	IngredientsFunction,
 	IngredientsModule,
+	inlineFunctionDef,
 	LedgerOfImports,
 	Make,
 	NodeChanger,
 	NodeTourist,
 	parseLogicalPath2astModule,
 	parsePathFilename2astModule,
-	Then,
+	removeUnusedParameters,
 	str_nameDOTname,
+	Then,
+	write_astModule,
 )
 from mapFolding.someAssemblyRequired.toolboxNumba import decorateCallableWithNumba, parametersNumbaLight
 from mapFolding.someAssemblyRequired.transformationTools import (
-	inlineFunctionDef,
 	removeDataclassFromFunction,
-	removeUnusedParameters,
 	shatter_dataclassesDOTdataclass,
 	unpackDataclassCallFunctionRepackDataclass,
-	write_astModule,
-	)
+)
 from pathlib import PurePath
 import ast
 
@@ -58,10 +58,7 @@ def makeInitializeGroupsOfFolds() -> None:
 	theCountingIdentifier = theCountingIdentifierHARDCODED
 
 	findThis = IfThis.isWhileAttributeNamespace_IdentifierGreaterThan0(dataclassInstanceIdentifier, 'leaf1ndex')
-	doThat = Grab.testAttribute(Grab.andDoAllOf([
-		Grab.opsAttribute(Then.replaceWith([ast.Eq()])), # type: ignore
-		Grab.leftAttribute(Grab.attrAttribute(Then.replaceWith(theCountingIdentifier))) # type: ignore
-	]))
+	doThat = Grab.testAttribute(Grab.andDoAllOf([ Grab.opsAttribute(Then.replaceWith([ast.Eq()])), Grab.leftAttribute(Grab.attrAttribute(Then.replaceWith(theCountingIdentifier))) ])) # type: ignore
 	NodeChanger(findThis, doThat).visit(countInitializeIngredients.astFunctionDef.body[0])
 
 	ingredientsModule = IngredientsModule(countInitializeIngredients)
@@ -171,7 +168,7 @@ def makeTheorem2() -> PurePath:
 	doThat = Then.removeIt
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
-	findThis = IfThis.isAttributeNamespace_IdentifierLessThanOrEqual(dataclassInstanceIdentifier, 'leaf1ndex')
+	findThis = IfThis.isAttributeNamespace_IdentifierLessThanOrEqual0(dataclassInstanceIdentifier, 'leaf1ndex')
 	doThat = Then.removeIt
 	NodeChanger(findThis, doThat).visit(countTheorem2.astFunctionDef)
 
@@ -301,7 +298,8 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom) -> None:
 	doTheNeedful.imports.addAst(astImportFrom)
 	targetCallableIdentifier = astImportFrom.names[0].name
 	doTheNeedful = unpackDataclassCallFunctionRepackDataclass(doTheNeedful, targetCallableIdentifier, shatteredDataclass)
-	targetFunctionDef = extractFunctionDef(parseLogicalPath2astModule(astImportFrom.module), targetCallableIdentifier) # type: ignore
+	if astImportFrom.module is None: raise raiseIfNoneGitHubIssueNumber3
+	targetFunctionDef = extractFunctionDef(parseLogicalPath2astModule(astImportFrom.module), targetCallableIdentifier)
 	if targetFunctionDef is None: raise raiseIfNoneGitHubIssueNumber3
 	astTuple: ast.Tuple | None = NodeTourist(Be.Return, Then.extractIt(DOT.value)).captureLastMatch(targetFunctionDef)
 	if astTuple is None: raise raiseIfNoneGitHubIssueNumber3

{mapfolding-0.10.0 → mapfolding-0.11.1}/mapFolding/someAssemblyRequired/__init__.py

@@ -44,45 +44,41 @@ optimizations - while maintaining the ability to verify correctness at each tran
 test suite.
 """
 
-from mapFolding.someAssemblyRequired._theTypes import (
+from astToolkit import (
 	ast_expr_Slice as ast_expr_Slice,
 	ast_Identifier as ast_Identifier,
-	ImaCallToName as ImaCallToName,
-	NodeORattribute as NodeORattribute,
-	str_nameDOTname as str_nameDOTname,
-	个 as 个,
-)
-
-from mapFolding.someAssemblyRequired._astTypes import *  # noqa: F403
-
-from mapFolding.someAssemblyRequired._toolboxPython import (
+	astModuleToIngredientsFunction as astModuleToIngredientsFunction,
+	Be as Be,
+	DOT as DOT,
+	extractClassDef as extractClassDef,
+	extractFunctionDef as extractFunctionDef,
+	Grab as Grab,
 	importLogicalPath2Callable as importLogicalPath2Callable,
 	importPathFilename2Callable as importPathFilename2Callable,
+	IngredientsFunction as IngredientsFunction,
+	IngredientsModule as IngredientsModule,
+	LedgerOfImports as LedgerOfImports,
+	Make as Make,
 	NodeChanger as NodeChanger,
+	NodeORattribute as NodeORattribute,
 	NodeTourist as NodeTourist,
 	parseLogicalPath2astModule as parseLogicalPath2astModule,
 	parsePathFilename2astModule as parsePathFilename2astModule,
+	str_nameDOTname as str_nameDOTname,
+	Then as Then,
 )
 
-from mapFolding.someAssemblyRequired._toolBe import Be as Be
-from mapFolding.someAssemblyRequired._toolDOT import DOT as DOT
-from mapFolding.someAssemblyRequired._toolGrab import Grab as Grab
-from mapFolding.someAssemblyRequired._toolMake import Make as Make
+from astToolkit.transformationTools import (
+	inlineFunctionDef as inlineFunctionDef,
+	removeUnusedParameters as removeUnusedParameters,
+	unparseFindReplace as unparseFindReplace,
+	write_astModule as write_astModule,
+)
 
 from mapFolding.someAssemblyRequired._toolIfThis import IfThis as IfThis
-from mapFolding.someAssemblyRequired._toolThen import Then as Then
 
 from mapFolding.someAssemblyRequired._toolboxContainers import (
 	DeReConstructField2ast as DeReConstructField2ast,
-	IngredientsFunction as IngredientsFunction,
-	IngredientsModule as IngredientsModule,
-	LedgerOfImports as LedgerOfImports,
 	RecipeSynthesizeFlow as RecipeSynthesizeFlow,
 	ShatteredDataclass as ShatteredDataclass,
 )
-
-from mapFolding.someAssemblyRequired._toolboxAST import (
-	astModuleToIngredientsFunction as astModuleToIngredientsFunction,
-	extractClassDef as extractClassDef,
-	extractFunctionDef as extractFunctionDef,
-)

mapfolding-0.11.1/mapFolding/someAssemblyRequired/_toolIfThis.py

@@ -0,0 +1,59 @@
+"""
+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:
+
+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.
+
+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).
+"""
+
+from astToolkit import IfThis as astToolkit_IfThis
+from collections.abc import Callable
+from mapFolding.someAssemblyRequired import ast_Identifier, Be
+from typing import TypeGuard
+import ast
+
+class IfThis(astToolkit_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 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 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 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_IdentifierLessThanOrEqual0(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]))

{mapfolding-0.10.0 → mapfolding-0.11.1}/mapFolding/someAssemblyRequired/_toolboxContainers.py

@@ -18,294 +18,15 @@ The containers work in conjunction with transformation tools that manipulate the
 specific optimizations and transformations.
 """
 
-from collections import defaultdict
-from collections.abc import Callable, Sequence
+from collections.abc import Callable
 from copy import deepcopy
-from typing import Any
-from mapFolding.someAssemblyRequired import ast_Identifier, DOT, IfThis, Make, NodeTourist, parseLogicalPath2astModule, str_nameDOTname, Then
+from mapFolding.someAssemblyRequired import ast_Identifier, DOT, IfThis, Make, NodeTourist, parseLogicalPath2astModule, str_nameDOTname, Then, LedgerOfImports
 from mapFolding.theSSOT import raiseIfNoneGitHubIssueNumber3, The
 from pathlib import Path, PurePosixPath
-from Z0Z_tools import updateExtendPolishDictionaryLists
+from typing import Any, cast
 import ast
 import dataclasses
 
-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:
-
-	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.
-	"""
-	# TODO When resolving the ledger of imports, remove self-referential imports
-
-	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, type_ignores: list[ast.TypeIgnore] | None = None) -> None:
-		match astImport____:
-			case ast.Import():
-				for alias in astImport____.names:
-					self.listImport.append(alias.name)
-			case ast.ImportFrom():
-				# TODO fix the mess created by `None` means '.'. I need a `str_nameDOTname` to replace '.'
-				if astImport____.module is None:
-					astImport____.module = '.'
-				for alias in astImport____.names:
-					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, 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, type_ignores: list[ast.TypeIgnore] | None = None) -> None:
-		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."""
-		self.removeImportFrom(moduleWithLogicalPath, None, None)
-
-	def removeImportFrom(self, moduleWithLogicalPath: str_nameDOTname, name: ast_Identifier | None, asname: ast_Identifier | None = None) -> None:
-		"""
-		name, 			asname				  	Action
-		None, 			None					: remove all matches for the module
-		ast_Identifier, ast_Identifier			: remove exact matches
-		ast_Identifier, None					: remove exact matches
-		None, 			ast_Identifier			: remove all matches for asname and if entry_asname is None remove name == ast_Identifier
-		"""
-		if moduleWithLogicalPath in self.dictionaryImportFrom:
-			if name is None and asname is None:
-				# Remove all entries for the module
-				self.dictionaryImportFrom.pop(moduleWithLogicalPath)
-			else:
-				if name is None:
-					self.dictionaryImportFrom[moduleWithLogicalPath] = [(entry_name, entry_asname) for entry_name, entry_asname in self.dictionaryImportFrom[moduleWithLogicalPath]
-													if not (entry_asname == asname) and not (entry_asname is None and entry_name == asname)]
-				else:
-					self.dictionaryImportFrom[moduleWithLogicalPath] = [(entry_name, entry_asname) for entry_name, entry_asname in self.dictionaryImportFrom[moduleWithLogicalPath]
-														if not (entry_name == name and entry_asname == asname)]
-				if not self.dictionaryImportFrom[moduleWithLogicalPath]:
-					self.dictionaryImportFrom.pop(moduleWithLogicalPath)
-
-	def exportListModuleIdentifiers(self) -> list[ast_Identifier]:
-		listModuleIdentifiers: list[ast_Identifier] = list(self.dictionaryImportFrom.keys())
-		listModuleIdentifiers.extend(self.listImport)
-		return sorted(set(listModuleIdentifiers))
-
-	def makeList_ast(self) -> list[ast.ImportFrom | ast.Import]:
-		listImportFrom: list[ast.ImportFrom] = []
-		for moduleWithLogicalPath, listOfNameTuples in sorted(self.dictionaryImportFrom.items()):
-			listOfNameTuples = sorted(list(set(listOfNameTuples)), key=lambda nameTuple: nameTuple[0])
-			list_alias: list[ast.alias] = []
-			for name, asname in listOfNameTuples:
-				list_alias.append(Make.alias(name, asname))
-			if list_alias:
-				listImportFrom.append(Make.ImportFrom(moduleWithLogicalPath, list_alias))
-		list_astImport: list[ast.Import] = [Make.Import(moduleWithLogicalPath) for moduleWithLogicalPath in sorted(set(self.listImport))]
-		return listImportFrom + list_astImport
-
-	def update(self, *fromLedger: 'LedgerOfImports') -> None:
-		"""Update this ledger with imports from one or more other ledgers.
-		Parameters:
-			*fromLedger: One or more other `LedgerOfImports` objects from which to merge.
-		"""
-		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)
-
-	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
-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:
-
-	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.
-
-	Parameters:
-		astFunctionDef: The AST representation of the function definition
-		imports: Import statements needed by the function
-		type_ignores: Type ignore comments associated with the function
-	"""
-	astFunctionDef: ast.FunctionDef
-	imports: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
-	type_ignores: list[ast.TypeIgnore] = dataclasses.field(default_factory=list)
-
-# Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
-@dataclasses.dataclass
-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:
-
-	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.
-
-	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`.
-	"""
-	ingredientsFunction: dataclasses.InitVar[Sequence[IngredientsFunction] | IngredientsFunction | None] = None
-
-	# init var with an existing module? method to deconstruct an existing module?
-
-	# `body` attribute of `ast.Module`
-	"""NOTE
-	- Bare statements in `prologue` and `epilogue` are not 'protected' by `if __name__ == '__main__':` so they will be executed merely by loading the module.
-	- The dataclass has methods for modifying `prologue`, `epilogue`, and `launcher`.
-	- However, `prologue`, `epilogue`, and `launcher` are `ast.Module` (as opposed to `list[ast.stmt]`), so that you may use tools such as `ast.walk` and `ast.NodeVisitor` on the fields.
-	"""
-	imports: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
-	"""Modify this field using the methods in `LedgerOfImports`."""
-	prologue: ast.Module = Make.Module([],[])
-	"""Statements after the imports and before the functions in listIngredientsFunctions."""
-	listIngredientsFunctions: list[IngredientsFunction] = dataclasses.field(default_factory=list)
-	epilogue: ast.Module = Make.Module([],[])
-	"""Statements after the functions in listIngredientsFunctions and before `launcher`."""
-	launcher: ast.Module = Make.Module([],[])
-	"""`if __name__ == '__main__':`"""
-
-	# `ast.TypeIgnore` statements to supplement those in other fields; `type_ignores` is a parameter for `ast.Module` constructor
-	supplemental_type_ignores: list[ast.TypeIgnore] = dataclasses.field(default_factory=list)
-
-	def __post_init__(self, ingredientsFunction: Sequence[IngredientsFunction] | IngredientsFunction | None = None) -> None:
-		if ingredientsFunction is not None:
-			if isinstance(ingredientsFunction, IngredientsFunction):
-				self.appendIngredientsFunction(ingredientsFunction)
-			else:
-				self.appendIngredientsFunction(*ingredientsFunction)
-
-	def _append_astModule(self, self_astModule: ast.Module, astModule: ast.Module | None, statement: Sequence[ast.stmt] | ast.stmt | None, type_ignores: list[ast.TypeIgnore] | None) -> None:
-		"""Append one or more statements to `prologue`."""
-		list_body: list[ast.stmt] = []
-		listTypeIgnore: list[ast.TypeIgnore] = []
-		if astModule is not None and isinstance(astModule, ast.Module): # type: ignore
-			list_body.extend(astModule.body)
-			listTypeIgnore.extend(astModule.type_ignores)
-		if type_ignores is not None:
-			listTypeIgnore.extend(type_ignores)
-		if statement is not None:
-			if isinstance(statement, Sequence):
-				list_body.extend(statement)
-			else:
-				list_body.append(statement)
-		self_astModule.body.extend(list_body)
-		self_astModule.type_ignores.extend(listTypeIgnore)
-		ast.fix_missing_locations(self_astModule)
-
-	def appendPrologue(self, astModule: ast.Module | None = None, statement: Sequence[ast.stmt] | ast.stmt | None = None, type_ignores: list[ast.TypeIgnore] | None = None) -> None:
-		"""Append one or more statements to `prologue`."""
-		self._append_astModule(self.prologue, astModule, statement, type_ignores)
-
-	def appendEpilogue(self, astModule: ast.Module | None = None, statement: Sequence[ast.stmt] | ast.stmt | None = None, type_ignores: list[ast.TypeIgnore] | None = None) -> None:
-		"""Append one or more statements to `epilogue`."""
-		self._append_astModule(self.epilogue, astModule, statement, type_ignores)
-
-	def appendLauncher(self, astModule: ast.Module | None = None, statement: Sequence[ast.stmt] | ast.stmt | None = None, type_ignores: list[ast.TypeIgnore] | None = None) -> None:
-		"""Append one or more statements to `launcher`."""
-		self._append_astModule(self.launcher, astModule, statement, type_ignores)
-
-	def appendIngredientsFunction(self, *ingredientsFunction: IngredientsFunction) -> None:
-		"""Append one or more `IngredientsFunction`."""
-		for allegedIngredientsFunction in ingredientsFunction:
-			self.listIngredientsFunctions.append(allegedIngredientsFunction)
-
-	def removeImportFromModule(self, moduleWithLogicalPath: str_nameDOTname) -> None:
-		self.removeImportFrom(moduleWithLogicalPath, None, None)
-		"""Remove all imports from a specific module."""
-
-	def removeImportFrom(self, moduleWithLogicalPath: str_nameDOTname, name: ast_Identifier | None, asname: ast_Identifier | None = None) -> None:
-		"""
-		This method modifies all `LedgerOfImports` in this `IngredientsModule` and all `IngredientsFunction` in `listIngredientsFunctions`.
-		It is not a "blacklist", so the `import from` could be added after this modification.
-		"""
-		self.imports.removeImportFrom(moduleWithLogicalPath, name, asname)
-		for ingredientsFunction in self.listIngredientsFunctions:
-			ingredientsFunction.imports.removeImportFrom(moduleWithLogicalPath, name, asname)
-
-	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
-
-	@property
-	def list_astImportImportFrom(self) -> list[ast.Import | ast.ImportFrom]:
-		return self._consolidatedLedger().makeList_ast()
-
-	@property
-	def body(self) -> list[ast.stmt]:
-		list_stmt: list[ast.stmt] = []
-		list_stmt.extend(self.list_astImportImportFrom)
-		list_stmt.extend(self.prologue.body)
-		for ingredientsFunction in self.listIngredientsFunctions:
-			list_stmt.append(ingredientsFunction.astFunctionDef)
-		list_stmt.extend(self.epilogue.body)
-		list_stmt.extend(self.launcher.body)
-		# TODO `launcher`, if it exists, must start with `if __name__ == '__main__':` and be indented
-		return list_stmt
-
-	@property
-	def type_ignores(self) -> list[ast.TypeIgnore]:
-		listTypeIgnore: list[ast.TypeIgnore] = self.supplemental_type_ignores
-		listTypeIgnore.extend(self._consolidatedLedger().type_ignores)
-		listTypeIgnore.extend(self.prologue.type_ignores)
-		for ingredientsFunction in self.listIngredientsFunctions:
-			listTypeIgnore.extend(ingredientsFunction.type_ignores)
-		listTypeIgnore.extend(self.epilogue.type_ignores)
-		listTypeIgnore.extend(self.launcher.type_ignores)
-		return listTypeIgnore
-
 # Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
 @dataclasses.dataclass
 class RecipeSynthesizeFlow:
@@ -436,10 +157,10 @@ class ShatteredDataclass:
 	countingVariableName: ast.Name
 	"""AST name node representing the counting variable identifier."""
 
-	field2AnnAssign: dict[ast_Identifier, ast.AnnAssign | ast.Assign] = dataclasses.field(default_factory=dict)
+	field2AnnAssign: dict[ast_Identifier, ast.AnnAssign | ast.Assign] = dataclasses.field(default_factory=lambda: dict[ast_Identifier, ast.AnnAssign | ast.Assign]())
 	"""Maps field names to their corresponding AST call expressions."""
 
-	Z0Z_field2AnnAssign: dict[ast_Identifier, tuple[ast.AnnAssign | ast.Assign, str]] = dataclasses.field(default_factory=dict)
+	Z0Z_field2AnnAssign: dict[ast_Identifier, tuple[ast.AnnAssign | ast.Assign, str]] = dataclasses.field(default_factory=lambda: dict[ast_Identifier, tuple[ast.AnnAssign | ast.Assign, str]]())
 
 	fragments4AssignmentOrParameters: ast.Tuple = dummyTuple
 	"""AST tuple used as target for assignment to capture returned fragments."""
@@ -447,22 +168,22 @@ class ShatteredDataclass:
 	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)
+	list_argAnnotated4ArgumentsSpecification: list[ast.arg] = dataclasses.field(default_factory=lambda: list[ast.arg]())
 	"""Function argument nodes with annotations for parameter specification."""
 
-	list_keyword_field__field4init: list[ast.keyword] = dataclasses.field(default_factory=list)
+	list_keyword_field__field4init: list[ast.keyword] = dataclasses.field(default_factory=lambda: list[ast.keyword]())
 	"""Keyword arguments for dataclass initialization with field=field format."""
 
-	listAnnotations: list[ast.expr] = dataclasses.field(default_factory=list)
+	listAnnotations: list[ast.expr] = dataclasses.field(default_factory=lambda: list[ast.expr]())
 	"""Type annotations for each dataclass field."""
 
-	listName4Parameters: list[ast.Name] = dataclasses.field(default_factory=list)
+	listName4Parameters: list[ast.Name] = dataclasses.field(default_factory=lambda: list[ast.Name]())
 	"""Name nodes for each dataclass field used as function parameters."""
 
-	listUnpack: list[ast.AnnAssign] = dataclasses.field(default_factory=list)
+	listUnpack: list[ast.AnnAssign] = dataclasses.field(default_factory=lambda: list[ast.AnnAssign]())
 	"""Annotated assignment statements to extract fields from dataclass."""
 
-	map_stateDOTfield2Name: dict[ast.AST, ast.Name] = dataclasses.field(default_factory=dict)
+	map_stateDOTfield2Name: dict[ast.AST, ast.Name] = dataclasses.field(default_factory=lambda: dict[ast.AST, ast.Name]())
 	"""Maps AST expressions to Name nodes for find-replace operations."""
 
 	repack: ast.Assign = dummyAssign
@@ -531,7 +252,13 @@ class DeReConstructField2ast:
 		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)
+		findThis = IfThis.isAnnAssign_targetIs(IfThis.isName_Identifier(self.name))
+
+		sherpa = NodeTourist(
+			findThis=findThis
+			, doThat=Then.extractIt(DOT.annotation)
+			).captureLastMatch(dataclassClassDef)
+
 		if sherpa is None: raise raiseIfNoneGitHubIssueNumber3
 		else: self.astAnnotation = sherpa
 
@@ -544,7 +271,7 @@ class DeReConstructField2ast:
 			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
+			dtype_asnameName: ast.Name = cast(ast.Name, self.astAnnotation)
 			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)]))
@@ -561,7 +288,7 @@ class DeReConstructField2ast:
 		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
+			takeTheTuple = deepcopy(self.astAnnotation.slice)
 			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, takeTheTuple)
 			self.Z0Z_hack = (self.astAnnAssignConstructor, elementConstructor)
 		if isinstance(self.astAnnotation, ast.Name):