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

mapFolding/someAssemblyRequired/_toolboxAntecedents.py

@@ -1,36 +1,39 @@
 """
 AST Node Predicate and Access Utilities for Pattern Matching and Traversal
 
-This module provides utilities for accessing and matching AST nodes in a consistent way.
-It contains three primary classes:
+This module provides utilities for accessing and matching AST nodes in a consistent way. It contains three primary
+classes:
 
-1. DOT: Provides consistent accessor methods for AST node attributes across different
-   node types, simplifying the access to node properties.
+1. DOT: Provides consistent accessor methods for AST node attributes across different node types, simplifying the access
+	to node properties.
 
-2. be: Offers type-guard functions that verify AST node types, enabling safe type
-   narrowing for static type checking and improving code safety.
+2. be: Offers type-guard functions that verify AST node types, enabling safe type narrowing for static type checking and
+	improving code safety.
 
-3. ifThis: Contains predicate functions for matching AST nodes based on various criteria,
-   enabling precise targeting of nodes for analysis or transformation.
+3. ifThis: Contains predicate functions for matching AST nodes based on various criteria, enabling precise targeting of
+	nodes for analysis or transformation.
 
-These utilities form the foundation of the pattern-matching component in the AST
-manipulation framework, working in conjunction with the NodeChanger and NodeTourist
-classes to enable precise and targeted code transformations. Together, they implement
-a declarative approach to AST manipulation that separates node identification (ifThis),
-type verification (be), and data access (DOT).
+These utilities form the foundation of the pattern-matching component in the AST manipulation framework, working in
+conjunction with the NodeChanger and NodeTourist classes to enable precise and targeted code transformations. Together,
+they implement a declarative approach to AST manipulation that separates node identification (ifThis), type verification
+(be), and data access (DOT).
 """
 
 from collections.abc import Callable
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
+	astClassHasDOTbody,
+	astClassHasDOTbody_expr,
+	astClassHasDOTbodyList_stmt,
 	astClassHasDOTnameNotName,
+	astClassHasDOTnameNotNameAlways,
+	astClassHasDOTnameNotNameOptionally,
+	astClassHasDOTtarget_expr,
 	astClassHasDOTtarget,
 	astClassHasDOTtargetAttributeNameSubscript,
-	astClassHasDOTtarget_expr,
-	astClassHasDOTvalue,
 	astClassHasDOTvalue_expr,
-	astClassOptionallyHasDOTnameNotName,
 	astClassHasDOTvalue_exprNone,
+	astClassHasDOTvalue,
 	ImaCallToName,
 )
 from typing import Any, overload, TypeGuard
@@ -72,6 +75,16 @@ class DOT:
 	def attr(node: ast.Attribute) -> ast_Identifier:
 		return node.attr
 
+	@staticmethod
+	@overload
+	def body(node: astClassHasDOTbodyList_stmt) -> list[ast.stmt]:...
+	@staticmethod
+	@overload
+	def body(node: astClassHasDOTbody_expr) -> ast.expr:...
+	@staticmethod
+	def body(node: astClassHasDOTbody) -> ast.expr | list[ast.stmt]:
+		return node.body
+
 	@staticmethod
 	@overload
 	def func(node: ImaCallToName) -> ast.Name:...
@@ -88,12 +101,12 @@ class DOT:
 
 	@staticmethod
 	@overload
-	def name(node: astClassHasDOTnameNotName) -> ast_Identifier:...
+	def name(node: astClassHasDOTnameNotNameAlways) -> ast_Identifier:...
 	@staticmethod
 	@overload
-	def name(node: astClassOptionallyHasDOTnameNotName) -> ast_Identifier | None:...
+	def name(node: astClassHasDOTnameNotNameOptionally) -> ast_Identifier | None:...
 	@staticmethod
-	def name(node: astClassHasDOTnameNotName | astClassOptionallyHasDOTnameNotName) -> ast_Identifier | None:
+	def name(node: astClassHasDOTnameNotName) -> ast_Identifier | None:
 		return node.name
 
 	@staticmethod
@@ -129,18 +142,16 @@ class be:
 	"""
 	Provide type-guard functions for safely verifying AST node types during manipulation.
 
-	The be class contains static methods that perform runtime type verification of AST nodes,
-	returning TypeGuard results that enable static type checkers to narrow node types in
-	conditional branches. These type-guards:
+	The be class contains static methods that perform runtime type verification of AST nodes, returning TypeGuard
+	results that enable static type checkers to narrow node types in conditional branches. These type-guards:
 
-	1. Improve code safety by preventing operations on incompatible node types
-	2. Enable IDE tooling to provide better autocompletion and error detection
-	3. Document expected node types in a way that's enforced by the type system
-	4. Support pattern-matching workflows where node types must be verified before access
+	1. Improve code safety by preventing operations on incompatible node types.
+	2. Enable IDE tooling to provide better autocompletion and error detection.
+	3. Document expected node types in a way that's enforced by the type system.
+	4. Support pattern-matching workflows where node types must be verified before access.
 
-	When used with conditional statements, these type-guards allow for precise,
-	type-safe manipulation of AST nodes while maintaining full static type checking
-	capabilities, even in complex transformation scenarios.
+	When used with conditional statements, these type-guards allow for precise, type-safe manipulation of AST nodes
+	while maintaining full static type checking capabilities, even in complex transformation scenarios.
 	"""
 	@staticmethod
 	def AnnAssign(node: ast.AST) -> TypeGuard[ast.AnnAssign]:
@@ -170,6 +181,14 @@ class be:
 	def ClassDef(node: ast.AST) -> TypeGuard[ast.ClassDef]:
 		return isinstance(node, ast.ClassDef)
 
+	@staticmethod
+	def Compare(node: ast.AST) -> TypeGuard[ast.Compare]:
+		return isinstance(node, ast.Compare)
+
+	@staticmethod
+	def Constant(node: ast.AST) -> TypeGuard[ast.Constant]:
+		return isinstance(node, ast.Constant)
+
 	@staticmethod
 	def FunctionDef(node: ast.AST) -> TypeGuard[ast.FunctionDef]:
 		return isinstance(node, ast.FunctionDef)
@@ -178,6 +197,18 @@ class be:
 	def keyword(node: ast.AST) -> TypeGuard[ast.keyword]:
 		return isinstance(node, ast.keyword)
 
+	@staticmethod
+	def If(node: ast.AST) -> TypeGuard[ast.If]:
+		return isinstance(node, ast.If)
+
+	@staticmethod
+	def Gt(node: ast.AST) -> TypeGuard[ast.Gt]:
+		return isinstance(node, ast.Gt)
+
+	@staticmethod
+	def LtE(node: ast.AST) -> TypeGuard[ast.LtE]:
+		return isinstance(node, ast.LtE)
+
 	@staticmethod
 	def Name(node: ast.AST) -> TypeGuard[ast.Name]:
 		return isinstance(node, ast.Name)
@@ -194,6 +225,14 @@ class be:
 	def Subscript(node: ast.AST) -> TypeGuard[ast.Subscript]:
 		return isinstance(node, ast.Subscript)
 
+	@staticmethod
+	def Tuple(node: ast.AST) -> TypeGuard[ast.Tuple]:
+		return isinstance(node, ast.Tuple)
+
+	@staticmethod
+	def While(node: ast.AST) -> TypeGuard[ast.While]:
+		return isinstance(node, ast.While)
+
 class ifThis:
 	"""
 	Provide predicate functions for matching and filtering AST nodes based on various criteria.
@@ -257,6 +296,29 @@ class ifThis:
 	def isAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Attribute] | bool]:
 		return lambda node: ifThis.isAttributeName(node) and ifThis.isName_Identifier(namespace)(DOT.value(node)) and ifThis._Identifier(identifier)(DOT.attr(node))
 
+	@staticmethod
+	def isAttributeNamespace_IdentifierGreaterThan0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
+		return lambda node: (be.Compare(node)
+					and ifThis.isAttributeNamespace_Identifier(namespace, identifier)(node.left)
+					and be.Gt(node.ops[0])
+					and ifThis.isConstant_value(0)(node.comparators[0]))
+
+	@staticmethod
+	def isIfAttributeNamespace_IdentifierGreaterThan0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.While] | bool]:
+		return lambda node: (be.If(node)
+					and ifThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(node.test))
+
+	@staticmethod
+	def isWhileAttributeNamespace_IdentifierGreaterThan0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.While] | bool]:
+		return lambda node: (be.While(node)
+					and ifThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(node.test))
+
+	@staticmethod
+	def isAttributeNamespace_IdentifierLessThanOrEqual(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
+		return lambda node: (be.Compare(node)
+					and ifThis.isAttributeNamespace_Identifier(namespace, identifier)(node.left)
+					and be.LtE(node.ops[0]))
+
 	@staticmethod
 	def isAugAssign_targetIs(targetPredicate: Callable[[ast.expr], TypeGuard[ast.expr] | bool]) -> Callable[[ast.AST], TypeGuard[ast.AugAssign] | bool]:
 		def workhorse(node: ast.AST) -> TypeGuard[ast.AugAssign] | bool:
@@ -282,6 +344,10 @@ class ifThis:
 	def isClassDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.ClassDef] | bool]:
 		return lambda node: be.ClassDef(node) and ifThis._Identifier(identifier)(DOT.name(node))
 
+	@staticmethod
+	def isConstant_value(value: Any) -> Callable[[ast.AST], TypeGuard[ast.Constant] | bool]:
+		return lambda node: be.Constant(node) and DOT.value(node) == value
+
 	@staticmethod
 	def isFunctionDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.FunctionDef] | bool]:
 		return lambda node: be.FunctionDef(node) and ifThis._Identifier(identifier)(DOT.name(node))

mapFolding/someAssemblyRequired/_toolboxContainers.py

@@ -32,8 +32,7 @@ class LedgerOfImports:
 	Track and manage import statements for programmatically generated code.
 
 	LedgerOfImports acts as a registry for import statements, maintaining a clean separation between the logical
-	structure of imports and their textual representation.
-	It enables:
+	structure of imports and their textual representation. It enables:
 
 	1. Tracking regular imports and import-from statements.
 	2. Adding imports programmatically during code transformation.
@@ -46,8 +45,6 @@ class LedgerOfImports:
 	"""
 	# TODO When resolving the ledger of imports, remove self-referential imports
 
-	type_ignores: list[ast.TypeIgnore]
-
 	def __init__(self, startWith: ast.AST | None = None, type_ignores: list[ast.TypeIgnore] | None = None) -> None:
 		self.dictionaryImportFrom: dict[str_nameDOTname, list[tuple[ast_Identifier, ast_Identifier | None]]] = defaultdict(list)
 		self.listImport: list[str_nameDOTname] = []
@@ -77,8 +74,6 @@ class LedgerOfImports:
 			self.type_ignores.extend(type_ignores)
 
 	def addImportFrom_asStr(self, moduleWithLogicalPath: str_nameDOTname, name: ast_Identifier, asname: ast_Identifier | None = None, type_ignores: list[ast.TypeIgnore] | None = None) -> None:
-		if moduleWithLogicalPath not in self.dictionaryImportFrom:
-			self.dictionaryImportFrom[moduleWithLogicalPath] = []
 		self.dictionaryImportFrom[moduleWithLogicalPath].append((name, asname))
 		if type_ignores:
 			self.type_ignores.extend(type_ignores)
@@ -131,7 +126,8 @@ class LedgerOfImports:
 		Parameters:
 			*fromLedger: One or more other `LedgerOfImports` objects from which to merge.
 		"""
-		self.dictionaryImportFrom = updateExtendPolishDictionaryLists(self.dictionaryImportFrom, *(ledger.dictionaryImportFrom for ledger in fromLedger), destroyDuplicates=True, reorderLists=True)
+		updatedDictionary = updateExtendPolishDictionaryLists(self.dictionaryImportFrom, *(ledger.dictionaryImportFrom for ledger in fromLedger), destroyDuplicates=True, reorderLists=True)
+		self.dictionaryImportFrom = defaultdict(list, updatedDictionary)
 		for ledger in fromLedger:
 			self.listImport.extend(ledger.listImport)
 			self.type_ignores.extend(ledger.type_ignores)
@@ -449,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

@@ -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]

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
 
@@ -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