mapFolding 0.10.0__py3-none-any.whl → 0.11.0__py3-none-any.whl

mapFolding/someAssemblyRequired/_toolboxContainers.py

@@ -18,294 +18,16 @@ 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 astToolkit import IngredientsFunction as IngredientsFunction, IngredientsModule as IngredientsModule, LedgerOfImports as LedgerOfImports
+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.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:
@@ -531,7 +253,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 +272,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 +289,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):

mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py

@@ -15,7 +15,7 @@ from mapFolding.someAssemblyRequired import (
 )
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2Numba
 from mapFolding.someAssemblyRequired.toolboxNumba import parametersNumbaLight, SpicesJobNumba, decorateCallableWithNumba
-from mapFolding.someAssemblyRequired.transformationTools import dictionaryEstimates, write_astModule, makeInitializedComputationState
+from mapFolding.someAssemblyRequired.transformationTools import write_astModule
 from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
 from mapFolding.dataBaskets import MapFoldingState
 from pathlib import PurePosixPath
@@ -77,7 +77,7 @@ if __name__ == '__main__':
 	ast_argNumbaProgress = ast.arg(arg=spices.numbaProgressBarIdentifier, annotation=ast.Name(id=numba_progressPythonClass, ctx=ast.Load()))
 	ingredientsFunction.astFunctionDef.args.args.append(ast_argNumbaProgress)
 
-	findThis = IfThis.isAugAssign_targetIs(IfThis.isName_Identifier(job.shatteredDataclass.countingVariableName.id))
+	findThis = IfThis.isAugAssignAndTargetIs(IfThis.isName_Identifier(job.shatteredDataclass.countingVariableName.id))
 	doThat = Then.replaceWith(Make.Expr(Make.Call(Make.Attribute(Make.Name(spices.numbaProgressBarIdentifier),'update'),[Make.Constant(1)])))
 	countWithProgressBar = NodeChanger(findThis, doThat)
 	countWithProgressBar.visit(ingredientsFunction.astFunctionDef)
@@ -131,19 +131,19 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 				ImaAnnAssign, elementConstructor = job.shatteredDataclass.Z0Z_field2AnnAssign[ast_arg.arg]
 				match elementConstructor:
 					case 'scalar':
-						ImaAnnAssign.value.args[0].value = int(job.state.__dict__[ast_arg.arg]) # type: ignore
+						cast(ast.Constant, cast(ast.Call, ImaAnnAssign.value).args[0]).value = int(job.state.__dict__[ast_arg.arg])
 					case 'array':
 						dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[ast_arg.arg], True)
 						dataAs_astExpr: ast.expr = cast(ast.Expr, ast.parse(dataAsStrRLE).body[0]).value
-						ImaAnnAssign.value.args = [dataAs_astExpr] # type: ignore
+						cast(ast.Call, ImaAnnAssign.value).args = [dataAs_astExpr]
 					case _:
 						list_exprDOTannotation: list[ast.expr] = []
 						list_exprDOTvalue: list[ast.expr] = []
 						for dimension in job.state.mapShape:
 							list_exprDOTannotation.append(Make.Name(elementConstructor))
 							list_exprDOTvalue.append(Make.Call(Make.Name(elementConstructor), [Make.Constant(dimension)]))
-						ImaAnnAssign.annotation.slice.elts = list_exprDOTannotation # type: ignore
-						ImaAnnAssign.value.elts = list_exprDOTvalue # type: ignore
+						cast(ast.Tuple, cast(ast.Subscript, cast(ast.AnnAssign, ImaAnnAssign).annotation).slice).elts = list_exprDOTannotation
+						cast(ast.Tuple, ImaAnnAssign.value).elts = list_exprDOTvalue
 
 				ingredientsFunction.astFunctionDef.body.insert(0, ImaAnnAssign)
 

mapFolding/someAssemblyRequired/synthesizeNumbaJob.py

@@ -95,7 +95,7 @@ if __name__ == '__main__':
 	ast_argNumbaProgress = ast.arg(arg=spices.numbaProgressBarIdentifier, annotation=ast.Name(id=numba_progressPythonClass, ctx=ast.Load()))
 	ingredientsFunction.astFunctionDef.args.args.append(ast_argNumbaProgress)
 
-	findThis = IfThis.isAugAssign_targetIs(IfThis.isName_Identifier(job.shatteredDataclass.countingVariableName.id))
+	findThis = IfThis.isAugAssignAndTargetIs(IfThis.isName_Identifier(job.shatteredDataclass.countingVariableName.id))
 	doThat = Then.replaceWith(Make.Expr(Make.Call(Make.Attribute(Make.Name(spices.numbaProgressBarIdentifier),'update'),[Make.Constant(1)])))
 	countWithProgressBar = NodeChanger(findThis, doThat)
 	countWithProgressBar.visit(ingredientsFunction.astFunctionDef)
@@ -149,19 +149,19 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 				ImaAnnAssign, elementConstructor = job.shatteredDataclass.Z0Z_field2AnnAssign[ast_arg.arg]
 				match elementConstructor:
 					case 'scalar':
-						ImaAnnAssign.value.args[0].value = int(job.state.__dict__[ast_arg.arg]) # type: ignore
+						cast(ast.Constant, cast(ast.Call, ImaAnnAssign.value).args[0]).value = int(job.state.__dict__[ast_arg.arg])
 					case 'array':
 						dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[ast_arg.arg], True)
 						dataAs_astExpr: ast.expr = cast(ast.Expr, ast.parse(dataAsStrRLE).body[0]).value
-						ImaAnnAssign.value.args = [dataAs_astExpr] # type: ignore
+						cast(ast.Call, ImaAnnAssign.value).args = [dataAs_astExpr]
 					case _:
 						list_exprDOTannotation: list[ast.expr] = []
 						list_exprDOTvalue: list[ast.expr] = []
 						for dimension in job.state.mapShape:
 							list_exprDOTannotation.append(Make.Name(elementConstructor))
 							list_exprDOTvalue.append(Make.Call(Make.Name(elementConstructor), [Make.Constant(dimension)]))
-						ImaAnnAssign.annotation.slice.elts = list_exprDOTannotation # type: ignore
-						ImaAnnAssign.value.elts = list_exprDOTvalue # type: ignore
+						cast(ast.Tuple, cast(ast.Subscript, cast(ast.AnnAssign, ImaAnnAssign).annotation).slice).elts = list_exprDOTannotation
+						cast(ast.Tuple, ImaAnnAssign.value).elts = list_exprDOTvalue
 
 				ingredientsFunction.astFunctionDef.body.insert(0, ImaAnnAssign)
 

mapFolding/someAssemblyRequired/transformationTools.py

@@ -18,7 +18,7 @@ readable, maintainable implementations to highly optimized versions while preser
 logical structure and correctness.
 """
 
-from autoflake import fix_code as autoflake_fix_code
+from astToolkit.transformationTools import ( inlineFunctionDef as inlineFunctionDef, removeUnusedParameters as removeUnusedParameters, write_astModule as write_astModule, )
 from collections.abc import Callable, Mapping
 from copy import deepcopy
 from mapFolding.beDRY import outfitCountFolds
@@ -27,7 +27,6 @@ from mapFolding.someAssemblyRequired import (
 	astModuleToIngredientsFunction,
 	Be,
 	DeReConstructField2ast,
-	DOT,
 	extractClassDef,
 	Grab,
 	IfThis,
@@ -45,102 +44,14 @@ from mapFolding.someAssemblyRequired import (
 	Then,
 	个,
 )
-from mapFolding.theSSOT import ComputationState, raiseIfNoneGitHubIssueNumber3, The
-from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal, writeStringToHere
+from mapFolding.theSSOT import ComputationState, The
+from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal
 from os import PathLike
 from pathlib import Path, PurePath
 from typing import Any, Literal, overload
 import ast
 import dataclasses
 import pickle
-import python_minifier
-
-def makeDictionaryFunctionDef(module: ast.Module) -> dict[ast_Identifier, ast.FunctionDef]:
-	"""
-	Create a dictionary mapping function names to their AST definitions.
-
-	This function creates a dictionary that maps function names to their AST function
-	definition nodes for all functions defined in the given module.
-
-	Parameters:
-		module: The AST module to extract function definitions from.
-
-	Returns:
-		A dictionary mapping function identifiers to their AST function definition nodes.
-	"""
-	dictionaryIdentifier2FunctionDef: dict[ast_Identifier, ast.FunctionDef] = {}
-	NodeTourist(Be.FunctionDef, Then.updateKeyValueIn(DOT.name, Then.extractIt, dictionaryIdentifier2FunctionDef)).visit(module)
-	return dictionaryIdentifier2FunctionDef
-
-def inlineFunctionDef(identifierToInline: ast_Identifier, module: ast.Module) -> ast.FunctionDef:
-	"""
-	Inline function calls within a function definition to create a self-contained function.
-
-	This function takes a function identifier and a module, finds the function definition,
-	and then recursively inlines all function calls within that function with their
-	implementation bodies. This produces a fully inlined function that doesn't depend
-	on other function definitions from the module.
-
-	Parameters:
-		identifierToInline: The name of the function to inline.
-		module: The AST module containing the function and its dependencies.
-
-	Returns:
-		A modified function definition with all function calls inlined.
-
-	Raises:
-		ValueError: If the function to inline is not found in the module.
-	"""
-	dictionaryFunctionDef: dict[ast_Identifier, ast.FunctionDef] = makeDictionaryFunctionDef(module)
-	try:
-		FunctionDefToInline = dictionaryFunctionDef[identifierToInline]
-	except KeyError as ERRORmessage:
-		raise ValueError(f"FunctionDefToInline not found in dictionaryIdentifier2FunctionDef: {identifierToInline = }") from ERRORmessage
-
-	listIdentifiersCalledFunctions: list[ast_Identifier] = []
-	findIdentifiersToInline = NodeTourist(findThis = IfThis.isCallToName, doThat = Grab.funcDOTidAttribute(Then.appendTo(listIdentifiersCalledFunctions)))
-	findIdentifiersToInline.visit(FunctionDefToInline)
-
-	dictionary4Inlining: dict[ast_Identifier, ast.FunctionDef] = {}
-	for identifier in sorted(set(listIdentifiersCalledFunctions).intersection(dictionaryFunctionDef.keys())):
-		if NodeTourist(IfThis.matchesMeButNotAnyDescendant(IfThis.isCall_Identifier(identifier)), Then.extractIt).captureLastMatch(module) is not None:
-			dictionary4Inlining[identifier] = dictionaryFunctionDef[identifier]
-
-	keepGoing = True
-	while keepGoing:
-		keepGoing = False
-		listIdentifiersCalledFunctions.clear()
-		findIdentifiersToInline.visit(Make.Module(list(dictionary4Inlining.values())))
-
-		listIdentifiersCalledFunctions = sorted((set(listIdentifiersCalledFunctions).difference(dictionary4Inlining.keys())).intersection(dictionaryFunctionDef.keys()))
-		if len(listIdentifiersCalledFunctions) > 0:
-			keepGoing = True
-			for identifier in listIdentifiersCalledFunctions:
-				if NodeTourist(IfThis.matchesMeButNotAnyDescendant(IfThis.isCall_Identifier(identifier)), Then.extractIt).captureLastMatch(module) is not None:
-					FunctionDefTarget = dictionaryFunctionDef[identifier]
-					if len(FunctionDefTarget.body) == 1:
-						replacement = NodeTourist(Be.Return, Then.extractIt(DOT.value)).captureLastMatch(FunctionDefTarget)
-
-						findThis = IfThis.isCall_Identifier(identifier)
-						doThat = Then.replaceWith(replacement)
-						inliner = NodeChanger(findThis, doThat)
-						for astFunctionDef in dictionary4Inlining.values():
-							inliner.visit(astFunctionDef)
-					else:
-						inliner = NodeChanger(IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(identifier)),Then.replaceWith(FunctionDefTarget.body[0:-1]))
-						for astFunctionDef in dictionary4Inlining.values():
-							inliner.visit(astFunctionDef)
-
-	for identifier, FunctionDefTarget in dictionary4Inlining.items():
-		if len(FunctionDefTarget.body) == 1:
-			replacement = NodeTourist(Be.Return, Then.extractIt(DOT.value)).captureLastMatch(FunctionDefTarget)
-			inliner = NodeChanger(IfThis.isCall_Identifier(identifier), Then.replaceWith(replacement))
-			inliner.visit(FunctionDefToInline)
-		else:
-			inliner = NodeChanger(IfThis.isAssignAndValueIs(IfThis.isCall_Identifier(identifier)),Then.replaceWith(FunctionDefTarget.body[0:-1]))
-			inliner.visit(FunctionDefToInline)
-	ast.fix_missing_locations(FunctionDefToInline)
-	return FunctionDefToInline
 
 @overload
 def makeInitializedComputationState(mapShape: tuple[int, ...], writeJob: Literal[True], *,  pathFilename: PathLike[str] | PurePath | None = None, **keywordArguments: Any) -> Path: ...
@@ -248,91 +159,7 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclas
 
 	return shatteredDataclass
 
-def write_astModule(ingredients: IngredientsModule, pathFilename: PathLike[Any] | PurePath, packageName: ast_Identifier | None = None) -> None:
-	"""
-	Convert an IngredientsModule to Python source code and write it to a file.
-
-	This function renders an IngredientsModule into executable Python code,
-	applies code quality improvements like import organization via autoflake,
-	and writes the result to the specified file path.
-
-	The function performs several key steps:
-	1. Converts the AST module structure to a valid Python AST
-	2. Fixes location attributes in the AST for proper formatting
-	3. Converts the AST to Python source code
-	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 assembly line,
-	producing optimized Python modules ready for execution.
-
-	Parameters:
-		ingredients: The IngredientsModule containing the module definition.
-		pathFilename: The file path where the module should be written.
-		packageName: Optional package name to preserve in import optimization.
-
-	Raises:
-		raiseIfNoneGitHubIssueNumber3: If the generated source code is empty.
-	"""
-	astModule = Make.Module(ingredients.body, ingredients.type_ignores)
-	ast.fix_missing_locations(astModule)
-	pythonSource: str = ast.unparse(astModule)
-	if not pythonSource: raise raiseIfNoneGitHubIssueNumber3
-	autoflake_additional_imports: list[str] = ingredients.imports.exportListModuleIdentifiers()
-	if packageName:
-		autoflake_additional_imports.append(packageName)
-	pythonSource = autoflake_fix_code(pythonSource, autoflake_additional_imports, expand_star_imports=False, remove_all_unused_imports=True, remove_duplicate_keys = False, remove_unused_variables = False)
-	# pythonSource = python_minifier.minify(pythonSource, remove_annotations=False, hoist_literals=False)
-	writeStringToHere(pythonSource, pathFilename)
-
 # 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] = []
-	fauxFunctionDef = deepcopy(ingredientsFunction.astFunctionDef)
-	NodeChanger(Be.Return, Then.removeIt).visit(fauxFunctionDef)
-	NodeTourist(Be.Name, Then.appendTo(listName)).visit(fauxFunctionDef)
-	list_Identifiers: list[ast_Identifier] = [astName.id for astName in listName]
-	list_IdentifiersNotUsed: list[ast_Identifier] = list(set(list_arg_arg) - set(list_Identifiers))
-	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:
 	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
 	listAllIngredientsFunctions = [
@@ -374,7 +201,7 @@ def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
 	for ingredients in listAllIngredientsFunctions:
 		for source_Identifier, recipe_Identifier in listFindReplace:
 			updateName = NodeChanger(IfThis.isName_Identifier(source_Identifier) , Grab.idAttribute(Then.replaceWith(recipe_Identifier)))
-			update_arg = NodeChanger(IfThis.isArgument_Identifier(source_Identifier), Grab.argAttribute(Then.replaceWith(recipe_Identifier))) # type: ignore
+			update_arg = NodeChanger(IfThis.isArgument_Identifier(source_Identifier), Grab.argAttribute(Then.replaceWith(recipe_Identifier)))
 			updateName.visit(ingredients.astFunctionDef)
 			update_arg.visit(ingredients.astFunctionDef)
 
@@ -494,7 +321,7 @@ def Z0Z_lameFindReplace(astTree: 个, mappingFindReplaceNodes: Mapping[ast.AST,
 
 	while keepGoing:
 		for nodeFind, nodeReplace in mappingFindReplaceNodes.items():
-			NodeChanger(IfThis.Z0Z_unparseIs(nodeFind), Then.replaceWith(nodeReplace)).visit(newTree)
+			NodeChanger(IfThis.unparseIs(nodeFind), Then.replaceWith(nodeReplace)).visit(newTree)
 
 		if ast.unparse(newTree) == ast.unparse(astTree):
 			keepGoing = False

{mapfolding-0.10.0.dist-info → mapfolding-0.11.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.10.0
+Version: 0.11.0
 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