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

mapFolding/someAssemblyRequired/_toolboxContainers.py

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

mapFolding/someAssemblyRequired/_toolboxPython.py

@@ -1,18 +1,17 @@
 """
 Core AST Traversal and Transformation Utilities for Python Code Manipulation
 
-This module provides the foundation for traversing and modifying Python Abstract
-Syntax Trees (ASTs). It contains two primary classes:
+This module provides the foundation for traversing and modifying Python Abstract Syntax Trees (ASTs). It contains two
+primary classes:
 
-1. NodeTourist: Implements the visitor pattern to traverse an AST and extract information
-   from nodes that match specific predicates without modifying the AST.
+1. NodeTourist: Implements the visitor pattern to traverse an AST and extract information from nodes that match specific
+	predicates without modifying the AST.
 
-2. NodeChanger: Extends ast.NodeTransformer to selectively transform AST nodes that
-   match specific predicates, enabling targeted code modifications.
+2. NodeChanger: Extends ast.NodeTransformer to selectively transform AST nodes that match specific predicates, enabling
+	targeted code modifications.
 
-The module also provides utilities for importing modules, loading callables from files,
-and parsing Python code into AST structures, creating a complete workflow for code
-analysis and transformation.
+The module also provides utilities for importing modules, loading callables from files, and parsing Python code into AST
+structures, creating a complete workflow for code analysis and transformation.
 """
 
 from collections.abc import Callable
@@ -32,13 +31,12 @@ class NodeTourist(ast.NodeVisitor):
 	"""
 	Visit and extract information from AST nodes that match a predicate.
 
-	NodeTourist implements the visitor pattern to traverse an AST, applying
-	a predicate function to each node and capturing nodes or their attributes
-	when they match. Unlike NodeChanger, it doesn't modify the AST but collects
+	NodeTourist implements the visitor pattern to traverse an AST, applying a predicate function to each node and
+	capturing nodes or their attributes when they match. Unlike NodeChanger, it doesn't modify the AST but collects
 	information during traversal.
 
-	This class is particularly useful for analyzing AST structures, extracting
-	specific nodes or node properties, and gathering information about code patterns.
+	This class is particularly useful for analyzing AST structures, extracting specific nodes or node properties, and
+	gathering information about code patterns.
 	"""
 	def __init__(self, findThis: Callable[..., Any], doThat: Callable[..., Any]) -> None:
 		self.findThis = findThis
@@ -61,12 +59,12 @@ class NodeChanger(ast.NodeTransformer):
 	"""
 	Transform AST nodes that match a predicate by applying a transformation function.
 
-	NodeChanger is an AST node transformer that applies a targeted transformation
-	to nodes matching a specific predicate. It traverses the AST and only modifies
-	nodes that satisfy the predicate condition, leaving other nodes unchanged.
+	NodeChanger is an AST node transformer that applies a targeted transformation to nodes matching a specific
+	predicate. It traverses the AST and only modifies nodes that satisfy the predicate condition, leaving other nodes
+	unchanged.
 
-	This class extends ast.NodeTransformer and implements the visitor pattern
-	to systematically process and transform an AST tree.
+	This class extends ast.NodeTransformer and implements the visitor pattern to systematically process and transform an
+	AST tree.
 	"""
 	def __init__(self, findThis: Callable[..., Any], doThat: Callable[..., Any]) -> None:
 		self.findThis = findThis
@@ -81,18 +79,18 @@ def importLogicalPath2Callable(logicalPathModule: str_nameDOTname, identifier: a
 	"""
 	Import a callable object (function or class) from a module based on its logical path.
 
-	This function imports a module using `importlib.import_module()` and then retrieves
-	a specific attribute (function, class, or other object) from that module.
+	This function imports a module using `importlib.import_module()` and then retrieves a specific attribute (function,
+	class, or other object) from that module.
 
 	Parameters
 	----------
-	logicalPathModule : str
+	logicalPathModule
 		The logical path to the module, using dot notation (e.g., 'package.subpackage.module').
-	identifier : str
+	identifier
 		The name of the callable object to retrieve from the module.
-	packageIdentifierIfRelative : str, optional
-		The package name to use as the anchor point if `logicalPathModule` is a relative import.
-		If None, absolute import is assumed.
+	packageIdentifierIfRelative : None
+		The package name to use as the anchor point if `logicalPathModule` is a relative import. If None, absolute
+		import is assumed.
 
 	Returns
 	-------
@@ -105,16 +103,17 @@ def importLogicalPath2Callable(logicalPathModule: str_nameDOTname, identifier: a
 def importPathFilename2Callable(pathFilename: PathLike[Any] | PurePath, identifier: ast_Identifier, moduleIdentifier: ast_Identifier | None = None) -> Callable[..., Any]:
 	"""
 	Load a callable (function, class, etc.) from a Python file.
-	This function imports a specified Python file as a module, extracts a callable object
-	from it by name, and returns that callable.
+
+	This function imports a specified Python file as a module, extracts a callable object from it by name, and returns
+	that callable.
 
 	Parameters
 	----------
-	pathFilename : Union[PathLike[Any], PurePath]
+	pathFilename
 		Path to the Python file to import.
-	identifier : str
+	identifier
 		Name of the callable to extract from the imported module.
-	moduleIdentifier : Optional[str]
+	moduleIdentifier
 		Name to use for the imported module. If None, the filename stem is used.
 
 	Returns
@@ -138,49 +137,52 @@ def importPathFilename2Callable(pathFilename: PathLike[Any] | PurePath, identifi
 	importlibSpecification.loader.exec_module(moduleImported_jk_hahaha)
 	return getattr(moduleImported_jk_hahaha, identifier)
 
-def parseLogicalPath2astModule(logicalPathModule: str_nameDOTname, packageIdentifierIfRelative: ast_Identifier|None=None, mode: Literal['exec'] = 'exec') -> ast.Module:
+def parseLogicalPath2astModule(logicalPathModule: str_nameDOTname, packageIdentifierIfRelative: ast_Identifier | None = None, mode: Literal['exec'] = 'exec') -> ast.Module:
 	"""
-	Parse a logical Python module path into an AST Module.
+	Parse a logical Python module path into an `ast.Module`.
 
-	This function imports a module using its logical path (e.g., 'package.subpackage.module')
-	and converts its source code into an Abstract Syntax Tree (AST) Module object.
+	This function imports a module using its logical path (e.g., 'package.subpackage.module') and converts its source
+	code into an Abstract Syntax Tree (AST) Module object.
 
 	Parameters
 	----------
-	logicalPathModule : str
+	logicalPathModule
 		The logical path to the module using dot notation (e.g., 'package.module').
-	packageIdentifierIfRelative : ast.Identifier or None, optional
+	packageIdentifierIfRelative : None
 		The package identifier to use if the module path is relative, defaults to None.
-	mode : Literal['exec'], optional
-		The parsing mode to use, defaults to 'exec'.
+	mode : Literal['exec']
+		The mode parameter for `ast.parse`. Default is `Literal['exec']`. Options are `Literal['exec']`, `"exec"` (which
+		is _not_ the same as `Literal['exec']`), `Literal['eval']`, `Literal['func_type']`, `Literal['single']`. See
+		`ast.parse` documentation for some details and much confusion.
 
 	Returns
 	-------
-	ast.Module
+	astModule
 		An AST Module object representing the parsed source code of the imported module.
 	"""
 	moduleImported: ModuleType = importlib.import_module(logicalPathModule, packageIdentifierIfRelative)
 	sourcePython: str = inspect_getsource(moduleImported)
-	return ast.parse(sourcePython, mode=mode)
+	return ast.parse(sourcePython, mode)
 
 def parsePathFilename2astModule(pathFilename: PathLike[Any] | PurePath, mode: Literal['exec'] = 'exec') -> ast.Module:
 	"""
-	Parse a file from a given path into an ast.Module.
+	Parse a file from a given path into an `ast.Module`.
 
-	This function reads the content of a file specified by `pathFilename` and parses it into an
-	Abstract Syntax Tree (AST) Module using Python's ast module.
+	This function reads the content of a file specified by `pathFilename` and parses it into an Abstract Syntax Tree
+	(AST) Module using Python's ast module.
 
 	Parameters
 	----------
-	pathFilename : PathLike[Any] | PurePath
+	pathFilename
 		The path to the file to be parsed. Can be a string path, PathLike object, or PurePath object.
-	mode : Literal['exec'], optional
-		The mode parameter for ast.parse. Default is 'exec'.
-		Options are 'exec', 'eval', or 'single'. See ast.parse documentation for details.
+	mode : Literal['exec']
+		The mode parameter for `ast.parse`. Default is `Literal['exec']`. Options are `Literal['exec']`, `"exec"` (which
+		is _not_ the same as `Literal['exec']`), `Literal['eval']`, `Literal['func_type']`, `Literal['single']`. See
+		`ast.parse` documentation for some details and much confusion.
 
 	Returns
 	-------
-	ast.Module
+	astModule
 		The parsed abstract syntax tree module.
 	"""
-	return ast.parse(Path(pathFilename).read_text(), mode=mode)
+	return ast.parse(Path(pathFilename).read_text(), mode)

mapFolding/someAssemblyRequired/synthesizeNumbaJob.py

@@ -6,7 +6,7 @@ for specific map folding calculation jobs. Unlike the general-purpose transforma
 in toolboxNumba.py, this module creates standalone Python modules optimized for a
 single map shape with statically-encoded parameters.
 
-The code generation pipeline focuses on:
+The code generation assembly line focuses on:
 
 1. Converting function parameters to initialized variables with concrete values.
 2. Replacing dynamic computations with statically-known values.
@@ -22,6 +22,7 @@ from mapFolding import getPathFilenameFoldsTotal, raiseIfNoneGitHubIssueNumber3,
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
 	be,
+	extractFunctionDef,
 	ifThis,
 	IngredientsFunction,
 	IngredientsModule,
@@ -34,7 +35,7 @@ from mapFolding.someAssemblyRequired import (
 )
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJob
 from mapFolding.someAssemblyRequired.toolboxNumba import parametersNumbaLight, SpicesJobNumba, decorateCallableWithNumba
-from mapFolding.someAssemblyRequired.transformationTools import dictionaryEstimates, extractFunctionDef, write_astModule, makeInitializedComputationState
+from mapFolding.someAssemblyRequired.transformationTools import dictionaryEstimates, write_astModule, makeInitializedComputationState
 from pathlib import PurePosixPath
 from typing import cast, NamedTuple
 from Z0Z_tools import autoDecodingRLE
@@ -131,7 +132,7 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 	Returns:
 		The modified function with parameters converted to initialized variables.
 	"""
-	ingredientsFunction.imports.update(job.shatteredDataclass.ledger)
+	ingredientsFunction.imports.update(job.shatteredDataclass.imports)
 
 	list_argCuzMyBrainRefusesToThink = ingredientsFunction.astFunctionDef.args.args + ingredientsFunction.astFunctionDef.args.posonlyargs + ingredientsFunction.astFunctionDef.args.kwonlyargs
 	list_arg_arg: list[ast_Identifier] = [ast_arg.arg for ast_arg in list_argCuzMyBrainRefusesToThink]
@@ -175,7 +176,7 @@ def makeJobNumba(job: RecipeJob, spices: SpicesJobNumba) -> None:
 	"""
 	Generate a highly-optimized, single-purpose Numba module for a specific map shape.
 
-	This function implements the complete transformation pipeline for creating a
+	This function implements the complete transformation assembly line for creating a
 	standalone, specialized implementation for calculating map folding solutions for
 	a specific shape. The process includes:
 
@@ -245,9 +246,9 @@ if __name__ == '__main__':
 		Z0Z_asname: ast_Identifier | None = None
 
 	listDatatypeConfigs = [
-		DatatypeConfig(fml='DatatypeLeavesTotal', Z0Z_module='numba', Z0Z_type_name='uint16'),
+		DatatypeConfig(fml='DatatypeLeavesTotal', Z0Z_module='numba', Z0Z_type_name='uint8'),
 		DatatypeConfig(fml='DatatypeElephino', Z0Z_module='numba', Z0Z_type_name='uint16'),
-		DatatypeConfig(fml='DatatypeFoldsTotal', Z0Z_module='numba', Z0Z_type_name='int64'),
+		DatatypeConfig(fml='DatatypeFoldsTotal', Z0Z_module='numba', Z0Z_type_name='uint64'),
 	]
 
 	for datatypeConfig in listDatatypeConfigs:
@@ -261,9 +262,9 @@ if __name__ == '__main__':
 	ingredientsCount.imports.removeImportFromModule('mapFolding.theSSOT')
 
 	listNumPyTypeConfigs = [
-		DatatypeConfig(fml='Array1DLeavesTotal', Z0Z_module='numpy', Z0Z_type_name='uint16', Z0Z_asname='Array1DLeavesTotal'),
+		DatatypeConfig(fml='Array1DLeavesTotal', Z0Z_module='numpy', Z0Z_type_name='uint8', Z0Z_asname='Array1DLeavesTotal'),
 		DatatypeConfig(fml='Array1DElephino', Z0Z_module='numpy', Z0Z_type_name='uint16', Z0Z_asname='Array1DElephino'),
-		DatatypeConfig(fml='Array3D', Z0Z_module='numpy', Z0Z_type_name='uint16', Z0Z_asname='Array3D'),
+		DatatypeConfig(fml='Array3D', Z0Z_module='numpy', Z0Z_type_name='uint8', Z0Z_asname='Array3D'),
 	]
 
 	for typeConfig in listNumPyTypeConfigs:
@@ -299,7 +300,7 @@ if __name__ == '__main__':
 	"""
 
 if __name__ == '__main__':
-	mapShape = (2,2,2,2,2,2,2,2)
+	mapShape = (2,21)
 	state = makeInitializedComputationState(mapShape)
 	# foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal
 	foldsTotalEstimated = dictionaryEstimates[state.mapShape] // state.leavesTotal

mapFolding/someAssemblyRequired/toolboxNumba.py

@@ -158,7 +158,7 @@ def makeNumbaFlow(numbaFlow: RecipeSynthesizeFlow) -> None:
 	"""
 	Transform standard Python algorithm code into optimized Numba implementations.
 
-	This function implements the complete transformation pipeline that converts
+	This function implements the complete transformation assembly line that converts
 	a conventional Python implementation into a high-performance Numba-accelerated
 	version. The process includes:
 

mapFolding/someAssemblyRequired/transformationTools.py

@@ -22,11 +22,12 @@ from autoflake import fix_code as autoflake_fix_code
 from collections.abc import Callable, Mapping
 from copy import deepcopy
 from mapFolding.beDRY import outfitCountFolds
-from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal, writeStringToHere
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
+	astModuleToIngredientsFunction,
 	be,
 	DOT,
+	extractClassDef,
 	grab,
 	ifThis,
 	importLogicalPath2Callable,
@@ -44,6 +45,7 @@ from mapFolding.someAssemblyRequired import (
 	个,
 )
 from mapFolding.theSSOT import ComputationState, raiseIfNoneGitHubIssueNumber3, The
+from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal, writeStringToHere
 from os import PathLike
 from pathlib import Path, PurePath
 from typing import Any, Literal, overload
@@ -52,59 +54,6 @@ import dataclasses
 import pickle
 import python_minifier
 
-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 and wraps it in an IngredientsFunction object along with its import context.
-
-	Parameters:
-		astModule: The AST module containing the function definition.
-		identifierFunctionDef: The name of the function to extract.
-
-	Returns:
-		An IngredientsFunction object containing the function definition and its imports.
-
-	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:
-		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: The matching function definition AST node, or None if not found.
-	"""
-	return NodeTourist(ifThis.isFunctionDef_Identifier(identifier), Then.extractIt).captureLastMatch(module)
-
 def makeDictionaryFunctionDef(module: ast.Module) -> dict[ast_Identifier, ast.FunctionDef]:
 	"""
 	Create a dictionary mapping function names to their AST definitions.
@@ -404,8 +353,8 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclas
 	shatteredDataclass.repack = Make.Assign(listTargets=[Make.Name(instance_Identifier)], value=Make.Call(Make.Name(dataclass_Identifier), list_astKeywords=shatteredDataclass.list_keyword_field__field4init))
 	shatteredDataclass.signatureReturnAnnotation = Make.Subscript(Make.Name('tuple'), Make.Tuple(shatteredDataclass.listAnnotations))
 
-	shatteredDataclass.ledger.update(*(dictionaryDeReConstruction[field].ledger for field in Official_fieldOrder))
-	shatteredDataclass.ledger.addImportFrom_asStr(logicalPathModule, dataclass_Identifier)
+	shatteredDataclass.imports.update(*(dictionaryDeReConstruction[field].ledger for field in Official_fieldOrder))
+	shatteredDataclass.imports.addImportFrom_asStr(logicalPathModule, dataclass_Identifier)
 
 	return shatteredDataclass
 
@@ -424,7 +373,7 @@ def write_astModule(ingredients: IngredientsModule, pathFilename: PathLike[Any]
 	4. Optimizes imports using autoflake
 	5. Writes the final source code to the specified file location
 
-	This is typically the final step in the code generation pipeline,
+	This is typically the final step in the code generation assembly line,
 	producing optimized Python modules ready for execution.
 
 	Parameters:
@@ -448,6 +397,27 @@ def write_astModule(ingredients: IngredientsModule, pathFilename: PathLike[Any]
 
 # END of acceptable classes and functions ======================================================
 def removeUnusedParameters(ingredientsFunction: IngredientsFunction) -> IngredientsFunction:
+	"""
+	Removes unused parameters from a function's AST definition, return statement, and annotation.
+
+	This function analyzes the Abstract Syntax Tree (AST) of a given function and removes
+	any parameters that are not referenced within the function body. It updates the
+	function signature, the return statement (if it's a tuple containing unused variables),
+	and the return type annotation accordingly.
+
+	Parameters
+	----------
+	ingredientsFunction : IngredientsFunction
+		An object containing the AST representation of a function to be processed.
+
+	Returns
+	-------
+	IngredientsFunction
+		The modified IngredientsFunction object with unused parameters and corresponding
+		return elements/annotations removed from its AST.
+
+	The modification is done in-place on the original AST nodes within the IngredientsFunction object.
+	"""
 	list_argCuzMyBrainRefusesToThink = ingredientsFunction.astFunctionDef.args.args + ingredientsFunction.astFunctionDef.args.posonlyargs + ingredientsFunction.astFunctionDef.args.kwonlyargs
 	list_arg_arg: list[ast_Identifier] = [ast_arg.arg for ast_arg in list_argCuzMyBrainRefusesToThink]
 	listName: list[ast.Name] = []
@@ -459,6 +429,18 @@ def removeUnusedParameters(ingredientsFunction: IngredientsFunction) -> Ingredie
 	for arg_Identifier in list_IdentifiersNotUsed:
 		remove_arg = NodeChanger(ifThis.is_arg_Identifier(arg_Identifier), Then.removeIt)
 		remove_arg.visit(ingredientsFunction.astFunctionDef)
+
+	list_argCuzMyBrainRefusesToThink = ingredientsFunction.astFunctionDef.args.args + ingredientsFunction.astFunctionDef.args.posonlyargs + ingredientsFunction.astFunctionDef.args.kwonlyargs
+
+	listName: list[ast.Name] = [Make.Name(ast_arg.arg) for ast_arg in list_argCuzMyBrainRefusesToThink]
+	replaceReturn = NodeChanger(be.Return, Then.replaceWith(Make.Return(Make.Tuple(listName))))
+	replaceReturn.visit(ingredientsFunction.astFunctionDef)
+
+	list_annotation: list[ast.expr] = [ast_arg.annotation for ast_arg in list_argCuzMyBrainRefusesToThink if ast_arg.annotation is not None]
+	ingredientsFunction.astFunctionDef.returns = Make.Subscript(Make.Name('tuple'), Make.Tuple(list_annotation))
+
+	ast.fix_missing_locations(ingredientsFunction.astFunctionDef)
+
 	return ingredientsFunction
 
 def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
@@ -514,7 +496,7 @@ def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
 	instance_Identifier = recipeFlow.dataclassInstance
 	getTheOtherRecord_damn = recipeFlow.dataclassInstanceTaskDistribution
 	shatteredDataclass = shatter_dataclassesDOTdataclass(recipeFlow.logicalPathModuleDataclass, recipeFlow.sourceDataclassIdentifier, instance_Identifier)
-	ingredientsDispatcher.imports.update(shatteredDataclass.ledger)
+	ingredientsDispatcher.imports.update(shatteredDataclass.imports)
 
 	# How can I use dataclass settings as the SSOT for specific actions? https://github.com/hunterhogan/mapFolding/issues/16
 	# Change callable parameters and Call to the callable at the same time ====

mapFolding/syntheticModules/dataPacking.py

@@ -0,0 +1,25 @@
+from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3D, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
+from mapFolding.syntheticModules.theorem2Numba import count
+
+def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+    mapShape: tuple[DatatypeLeavesTotal, ...] = state.mapShape
+    groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
+    gap1ndex: DatatypeElephino = state.gap1ndex
+    gap1ndexCeiling: DatatypeElephino = state.gap1ndexCeiling
+    indexDimension: DatatypeLeavesTotal = state.indexDimension
+    indexLeaf: DatatypeLeavesTotal = state.indexLeaf
+    indexMiniGap: DatatypeElephino = state.indexMiniGap
+    leaf1ndex: DatatypeLeavesTotal = state.leaf1ndex
+    leafConnectee: DatatypeLeavesTotal = state.leafConnectee
+    dimensionsUnconstrained: DatatypeLeavesTotal = state.dimensionsUnconstrained
+    countDimensionsGapped: Array1DLeavesTotal = state.countDimensionsGapped
+    gapRangeStart: Array1DElephino = state.gapRangeStart
+    gapsWhere: Array1DLeavesTotal = state.gapsWhere
+    leafAbove: Array1DLeavesTotal = state.leafAbove
+    leafBelow: Array1DLeavesTotal = state.leafBelow
+    connectionGraph: Array3D = state.connectionGraph
+    dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
+    leavesTotal: DatatypeLeavesTotal = state.leavesTotal
+    groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal)
+    state = MapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow)
+    return state