mapFolding 0.9.5__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.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)]))
@@ -552,8 +280,8 @@ class DeReConstructField2ast:
 			self.ledger.addImportFrom_asStr(moduleWithLogicalPath, constructor)
 			dtypeIdentifier: ast_Identifier = dtype.__name__
 			self.ledger.addImportFrom_asStr(moduleWithLogicalPath, dtypeIdentifier, dtype_asnameName.id)
-			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, ast_expr, Make.Call(Make.Name(constructor), list_astKeywords=[Make.keyword('dtype', dtype_asnameName)]))
-			self.astAnnAssignConstructor = Make.Assign([self.astName], Make.Call(Make.Name(constructor), list_astKeywords=[Make.keyword('dtype', dtype_asnameName)]))
+			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, ast_expr, Make.Call(Make.Name(constructor), list_keyword=[Make.keyword('dtype', dtype_asnameName)]))
+			self.astAnnAssignConstructor = Make.Assign([self.astName], Make.Call(Make.Name(constructor), list_keyword=[Make.keyword('dtype', dtype_asnameName)]))
 			self.Z0Z_hack = (self.astAnnAssignConstructor, 'array')
 		elif isinstance(self.astAnnotation, ast.Name):
 			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, Make.Call(self.astAnnotation, [Make.Constant(-1)]))
@@ -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

@@ -1,9 +1,9 @@
 from mapFolding import getPathFilenameFoldsTotal, raiseIfNoneGitHubIssueNumber3, The
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
-	be,
+	Be,
 	extractFunctionDef,
-	ifThis,
+	IfThis,
 	IngredientsFunction,
 	IngredientsModule,
 	LedgerOfImports,
@@ -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,12 +77,12 @@ 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)
 
-	removeReturnStatement = NodeChanger(be.Return, Then.removeIt)
+	removeReturnStatement = NodeChanger(Be.Return, Then.removeIt)
 	removeReturnStatement.visit(ingredientsFunction.astFunctionDef)
 	ingredientsFunction.astFunctionDef.returns = Make.Constant(value=None)
 
@@ -119,7 +119,7 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 	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] = []
-	NodeTourist(be.Name, Then.appendTo(listName)).visit(ingredientsFunction.astFunctionDef)
+	NodeTourist(Be.Name, Then.appendTo(listName)).visit(ingredientsFunction.astFunctionDef)
 	list_Identifiers: list[ast_Identifier] = [astName.id for astName in listName]
 	list_IdentifiersNotUsed: list[ast_Identifier] = list(set(list_arg_arg) - set(list_Identifiers))
 
@@ -131,23 +131,23 @@ 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)
 
-			findThis = ifThis.is_arg_Identifier(ast_arg.arg)
+			findThis = IfThis.is_arg_Identifier(ast_arg.arg)
 			remove_arg = NodeChanger(findThis, Then.removeIt)
 			remove_arg.visit(ingredientsFunction.astFunctionDef)
 
@@ -161,7 +161,7 @@ def makeJobNumba(job: RecipeJobTheorem2Numba, spices: SpicesJobNumba) -> None:
 	ingredientsCount: IngredientsFunction = IngredientsFunction(astFunctionDef, LedgerOfImports())
 
 	# Remove `foldGroups` and any other unused statements, so you can dynamically determine which variables are not used
-	findThis = ifThis.isAssignAndTargets0Is(ifThis.isSubscript_Identifier('foldGroups'))
+	findThis = IfThis.isAssignAndTargets0Is(IfThis.isSubscript_Identifier('foldGroups'))
 	doThat = Then.removeIt
 	remove_foldGroups = NodeChanger(findThis, doThat)
 	remove_foldGroups.visit(ingredientsCount.astFunctionDef)
@@ -169,7 +169,7 @@ def makeJobNumba(job: RecipeJobTheorem2Numba, spices: SpicesJobNumba) -> None:
 	# replace identifiers with static values with their values, so you can dynamically determine which variables are not used
 	list_IdentifiersStaticValues = list_IdentifiersStaticValuesHARDCODED
 	for identifier in list_IdentifiersStaticValues:
-		findThis = ifThis.isName_Identifier(identifier)
+		findThis = IfThis.isName_Identifier(identifier)
 		doThat = Then.replaceWith(Make.Constant(int(job.state.__dict__[identifier])))
 		NodeChanger(findThis, doThat).visit(ingredientsCount.astFunctionDef)
 
@@ -193,7 +193,7 @@ if __name__ == '__main__':
 	# from mapFolding.oeis import getFoldsTotalKnown
 	# print(foldsTotal == getFoldsTotalKnown({job.state.mapShape}))
 		ingredientsModule.appendLauncher(ast.parse(linesLaunch))
-		changeReturnParallelCallable = NodeChanger(be.Return, Then.replaceWith(Make.Return(job.shatteredDataclass.countingVariableName)))
+		changeReturnParallelCallable = NodeChanger(Be.Return, Then.replaceWith(Make.Return(job.shatteredDataclass.countingVariableName)))
 		changeReturnParallelCallable.visit(ingredientsCount.astFunctionDef)
 		ingredientsCount.astFunctionDef.returns = job.shatteredDataclass.countingVariableAnnotation
 

mapFolding/someAssemblyRequired/synthesizeNumbaJob.py

@@ -21,9 +21,9 @@ as Python scripts or further compiled into standalone executables.
 from mapFolding import getPathFilenameFoldsTotal, raiseIfNoneGitHubIssueNumber3, The
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
-	be,
+	Be,
 	extractFunctionDef,
-	ifThis,
+	IfThis,
 	IngredientsFunction,
 	IngredientsModule,
 	LedgerOfImports,
@@ -95,12 +95,12 @@ 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)
 
-	removeReturnStatement = NodeChanger(be.Return, Then.removeIt)
+	removeReturnStatement = NodeChanger(Be.Return, Then.removeIt)
 	removeReturnStatement.visit(ingredientsFunction.astFunctionDef)
 	ingredientsFunction.astFunctionDef.returns = Make.Constant(value=None)
 
@@ -137,7 +137,7 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 	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] = []
-	NodeTourist(be.Name, Then.appendTo(listName)).visit(ingredientsFunction.astFunctionDef)
+	NodeTourist(Be.Name, Then.appendTo(listName)).visit(ingredientsFunction.astFunctionDef)
 	list_Identifiers: list[ast_Identifier] = [astName.id for astName in listName]
 	list_IdentifiersNotUsed: list[ast_Identifier] = list(set(list_arg_arg) - set(list_Identifiers))
 
@@ -149,23 +149,23 @@ 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)
 
-			findThis = ifThis.is_arg_Identifier(ast_arg.arg)
+			findThis = IfThis.is_arg_Identifier(ast_arg.arg)
 			remove_arg = NodeChanger(findThis, Then.removeIt)
 			remove_arg.visit(ingredientsFunction.astFunctionDef)
 
@@ -201,7 +201,7 @@ def makeJobNumba(job: RecipeJob, spices: SpicesJobNumba) -> None:
 	ingredientsCount: IngredientsFunction = IngredientsFunction(astFunctionDef, LedgerOfImports())
 
 	# Remove `foldGroups` and any other unused statements, so you can dynamically determine which variables are not used
-	findThis = ifThis.isAssignAndTargets0Is(ifThis.isSubscript_Identifier('foldGroups'))
+	findThis = IfThis.isAssignAndTargets0Is(IfThis.isSubscript_Identifier('foldGroups'))
 	doThat = Then.removeIt
 	remove_foldGroups = NodeChanger(findThis, doThat)
 	remove_foldGroups.visit(ingredientsCount.astFunctionDef)
@@ -209,7 +209,7 @@ def makeJobNumba(job: RecipeJob, spices: SpicesJobNumba) -> None:
 	# replace identifiers with static values with their values, so you can dynamically determine which variables are not used
 	list_IdentifiersStaticValues = list_IdentifiersStaticValuesHARDCODED
 	for identifier in list_IdentifiersStaticValues:
-		findThis = ifThis.isName_Identifier(identifier)
+		findThis = IfThis.isName_Identifier(identifier)
 		doThat = Then.replaceWith(Make.Constant(int(job.state.__dict__[identifier])))
 		NodeChanger(findThis, doThat).visit(ingredientsCount.astFunctionDef)
 
@@ -233,7 +233,7 @@ if __name__ == '__main__':
 	# from mapFolding.oeis import getFoldsTotalKnown
 	# print(foldsTotal == getFoldsTotalKnown({job.state.mapShape}))
 		ingredientsModule.appendLauncher(ast.parse(linesLaunch))
-		changeReturnParallelCallable = NodeChanger(be.Return, Then.replaceWith(Make.Return(job.shatteredDataclass.countingVariableName)))
+		changeReturnParallelCallable = NodeChanger(Be.Return, Then.replaceWith(Make.Return(job.shatteredDataclass.countingVariableName)))
 		changeReturnParallelCallable.visit(ingredientsCount.astFunctionDef)
 		ingredientsCount.astFunctionDef.returns = job.shatteredDataclass.countingVariableAnnotation
 

mapFolding/someAssemblyRequired/toolboxNumba.py

@@ -123,7 +123,7 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 	ingredientsFunction.imports.addImportFrom_asStr(decoratorModule, decoratorCallable)
 	# Leave this line in so that global edits will change it.
 	astDecorator: ast.Call = Make.Call(Make.Name(decoratorCallable), list_argsDecorator, listDecoratorKeywords)
-	astDecorator: ast.Call = Make.Call(Make.Name(decoratorCallable), list_astKeywords=listDecoratorKeywords)
+	astDecorator: ast.Call = Make.Call(Make.Name(decoratorCallable), list_keyword=listDecoratorKeywords)
 
 	ingredientsFunction.astFunctionDef.decorator_list = [astDecorator]
 	return ingredientsFunction