mapFolding 0.8.2__py3-none-any.whl → 0.8.4__py3-none-any.whl

mapFolding/someAssemblyRequired/_toolboxContainers.py

@@ -0,0 +1,306 @@
+"""
+Container classes for AST transformations and code synthesis.
+
+This module provides container classes used in the AST transformation process
+and code synthesis workflows. It acts as a dependency boundary to prevent
+circular imports while providing reusable data structures.
+"""
+from collections import defaultdict
+from collections.abc import Sequence
+from mapFolding.someAssemblyRequired import ast_Identifier, be, ifThis, Make, parseLogicalPath2astModule, str_nameDOTname
+from mapFolding.theSSOT import callableDispatcherHARDCODED, raiseIfNoneGitHubIssueNumber3, The
+from pathlib import Path, PurePosixPath
+from Z0Z_tools import updateExtendPolishDictionaryLists
+import ast
+import dataclasses
+
+class LedgerOfImports:
+	# TODO When resolving the ledger of imports, remove self-referential imports
+	# TODO TypeIgnore :/
+
+	def __init__(self, startWith: ast.AST | None = None) -> None:
+		self.dictionaryImportFrom: dict[str_nameDOTname, list[tuple[ast_Identifier, ast_Identifier | None]]] = defaultdict(list)
+		self.listImport: list[str_nameDOTname] = []
+		if startWith:
+			self.walkThis(startWith)
+
+	def addAst(self, astImport____: ast.Import | ast.ImportFrom) -> None:
+		assert isinstance(astImport____, (ast.Import, ast.ImportFrom)), f"I received {type(astImport____) = }, but I can only accept {ast.Import} and {ast.ImportFrom}."
+		if be.Import(astImport____):
+			for alias in astImport____.names:
+				self.listImport.append(alias.name)
+		elif be.ImportFrom(astImport____):
+			# 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))
+
+	def addImport_asStr(self, moduleIdentifier: str_nameDOTname) -> None:
+		self.listImport.append(moduleIdentifier)
+
+	def addImportFrom_asStr(self, moduleIdentifier: ast_Identifier, name: ast_Identifier, asname: ast_Identifier | None = None) -> None:
+		self.dictionaryImportFrom[moduleIdentifier].append((name, asname))
+
+	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 moduleIdentifier, 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))
+			listImportFrom.append(Make.ImportFrom(moduleIdentifier, list_alias))
+		list_astImport: list[ast.Import] = [Make.Import(moduleIdentifier) for moduleIdentifier 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.
+		"""
+		self.dictionaryImportFrom = updateExtendPolishDictionaryLists(self.dictionaryImportFrom, *(ledger.dictionaryImportFrom for ledger in fromLedger), destroyDuplicates=True, reorderLists=True)
+		for ledger in fromLedger:
+			self.listImport.extend(ledger.listImport)
+
+	def walkThis(self, walkThis: ast.AST) -> None:
+		for nodeBuffalo in ast.walk(walkThis):
+			if isinstance(nodeBuffalo, (ast.Import, ast.ImportFrom)):
+				self.addAst(nodeBuffalo)
+
+@dataclasses.dataclass
+class IngredientsFunction:
+	"""Everything necessary to integrate a function into a module should be here.
+	Parameters:
+		astFunctionDef: hint `Make.astFunctionDef()`
+	"""
+	astFunctionDef: ast.FunctionDef
+	imports: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
+	type_ignores: list[ast.TypeIgnore] = dataclasses.field(default_factory=list)
+
+@dataclasses.dataclass
+class IngredientsModule:
+	"""Everything necessary to create one _logical_ `ast.Module` should be here.
+	Extrinsic qualities should _probably_ be handled externally.
+
+	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 be.Module(astModule):
+			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:
+			if isinstance(allegedIngredientsFunction, IngredientsFunction):
+				self.listIngredientsFunctions.append(allegedIngredientsFunction)
+			else:
+				raise ValueError(f"I received `{type(allegedIngredientsFunction) = }`, but I can only accept `{IngredientsFunction}`.")
+
+	@property
+	def list_astImportImportFrom(self) -> list[ast.Import | ast.ImportFrom]:
+		"""List of `ast.Import` and `ast.ImportFrom` statements."""
+		sherpaLedger = LedgerOfImports()
+		listLedgers: list[LedgerOfImports] = [self.imports]
+		for ingredientsFunction in self.listIngredientsFunctions:
+			listLedgers.append(ingredientsFunction.imports)
+		sherpaLedger.update(*listLedgers)
+		return sherpaLedger.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.imports.makeListAst())
+		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
+
+@dataclasses.dataclass
+class RecipeSynthesizeFlow:
+	"""Settings for synthesizing flow."""
+	# ========================================
+	# Source
+	# ========================================
+	source_astModule = parseLogicalPath2astModule(The.logicalPathModuleSourceAlgorithm)
+
+	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
+	sourceCallableDispatcher: ast_Identifier = The.sourceCallableDispatcher
+	sourceCallableInitialize: ast_Identifier = The.sourceCallableInitialize
+	sourceCallableParallel: ast_Identifier = The.sourceCallableParallel
+	sourceCallableSequential: ast_Identifier = The.sourceCallableSequential
+
+	sourceDataclassIdentifier: ast_Identifier = The.dataclassIdentifier
+	sourceDataclassInstance: ast_Identifier = The.dataclassInstance
+	sourceDataclassInstanceTaskDistribution: ast_Identifier = The.dataclassInstanceTaskDistribution
+	sourceLogicalPathModuleDataclass: str_nameDOTname = The.logicalPathModuleDataclass
+
+	sourceConcurrencyManagerNamespace = The.sourceConcurrencyManagerNamespace
+	sourceConcurrencyManagerIdentifier = The.sourceConcurrencyManagerIdentifier
+
+	# ========================================
+	# Logical identifiers (as opposed to physical identifiers)
+	# ========================================
+	# Package ================================
+	packageIdentifier: ast_Identifier | None = The.packageName
+
+	# Qualified logical path ================================
+	logicalPathModuleDataclass: str_nameDOTname = sourceLogicalPathModuleDataclass
+	logicalPathFlowRoot: ast_Identifier | None = 'syntheticModules'
+	""" `logicalPathFlowRoot` likely corresponds to a physical filesystem directory."""
+
+	# Module ================================
+	moduleDispatcher: ast_Identifier = 'numbaCount_doTheNeedful'
+	moduleInitialize: ast_Identifier = moduleDispatcher
+	moduleParallel: ast_Identifier = moduleDispatcher
+	moduleSequential: ast_Identifier = moduleDispatcher
+
+	# Function ================================
+	callableDispatcher: ast_Identifier = sourceCallableDispatcher
+	callableInitialize: ast_Identifier = sourceCallableInitialize
+	callableParallel: ast_Identifier = sourceCallableParallel
+	callableSequential: ast_Identifier = sourceCallableSequential
+	concurrencyManagerNamespace: ast_Identifier = sourceConcurrencyManagerNamespace
+	concurrencyManagerIdentifier: ast_Identifier = sourceConcurrencyManagerIdentifier
+	dataclassIdentifier: ast_Identifier = sourceDataclassIdentifier
+
+	# Variable ================================
+	dataclassInstance: ast_Identifier = sourceDataclassInstance
+	dataclassInstanceTaskDistribution: ast_Identifier = sourceDataclassInstanceTaskDistribution
+
+	# ========================================
+	# Computed
+	# ========================================
+	"""
+theFormatStrModuleSynthetic = "{packageFlow}Count"
+theFormatStrModuleForCallableSynthetic = theFormatStrModuleSynthetic + "_{callableTarget}"
+theModuleDispatcherSynthetic: ast_Identifier = theFormatStrModuleForCallableSynthetic.format(packageFlow=packageFlowSynthetic, callableTarget=The.sourceCallableDispatcher)
+theLogicalPathModuleDispatcherSynthetic: str = '.'.join([The.packageName, The.moduleOfSyntheticModules, theModuleDispatcherSynthetic])
+
+	"""
+	# logicalPathModuleDispatcher: str = '.'.join([Z0Z_flowLogicalPathRoot, moduleDispatcher])
+	# ========================================
+	# Filesystem (names of physical objects)
+	# ========================================
+	pathPackage: PurePosixPath | None = PurePosixPath(The.pathPackage)
+	fileExtension: str = The.fileExtension
+
+	def _makePathFilename(self, filenameStem: str,
+			pathRoot: PurePosixPath | None = None,
+			logicalPathINFIX: str_nameDOTname | None = None,
+			fileExtension: str | None = None,
+			) -> PurePosixPath:
+		"""filenameStem: (hint: the name of the logical module)"""
+		if pathRoot is None:
+			pathRoot = self.pathPackage or PurePosixPath(Path.cwd())
+		if logicalPathINFIX:
+			whyIsThisStillAThing: list[str] = logicalPathINFIX.split('.')
+			pathRoot = pathRoot.joinpath(*whyIsThisStillAThing)
+		if fileExtension is None:
+			fileExtension = self.fileExtension
+		filename: str = filenameStem + fileExtension
+		return pathRoot.joinpath(filename)
+
+	@property
+	def pathFilenameDispatcher(self) -> PurePosixPath:
+		return self._makePathFilename(filenameStem=self.moduleDispatcher, logicalPathINFIX=self.logicalPathFlowRoot)
+	@property
+	def pathFilenameInitialize(self) -> PurePosixPath:
+		return self._makePathFilename(filenameStem=self.moduleInitialize, logicalPathINFIX=self.logicalPathFlowRoot)
+	@property
+	def pathFilenameParallel(self) -> PurePosixPath:
+		return self._makePathFilename(filenameStem=self.moduleParallel, logicalPathINFIX=self.logicalPathFlowRoot)
+	@property
+	def pathFilenameSequential(self) -> PurePosixPath:
+		return self._makePathFilename(filenameStem=self.moduleSequential, logicalPathINFIX=self.logicalPathFlowRoot)
+
+	def __post_init__(self) -> None:
+		if ((self.concurrencyManagerIdentifier is not None and self.concurrencyManagerIdentifier != self.sourceConcurrencyManagerIdentifier) # `submit` # type: ignore
+			or ((self.concurrencyManagerIdentifier is None) != (self.concurrencyManagerNamespace is None))): # type: ignore
+			import warnings
+			warnings.warn(f"If your synthesized module is weird, check `{self.concurrencyManagerIdentifier=}` and `{self.concurrencyManagerNamespace=}`. (ChildProcessError? 'Yeah! Children shouldn't be processing stuff, man.')", category=ChildProcessError, stacklevel=2) # pyright: ignore[reportCallIssue, reportArgumentType] Y'all Pynatics need to be less shrill and focus on making code that doesn't need 8000 error categories.
+
+		# self.logicalPathModuleDispatcher!=logicalPathModuleDispatcherHARDCODED or
+		if self.callableDispatcher!=callableDispatcherHARDCODED:
+			print(f"fyi: `{self.callableDispatcher=}` but\n\t`{callableDispatcherHARDCODED=}`.")
+
+def astModuleToIngredientsFunction(astModule: ast.AST, identifierFunctionDef: ast_Identifier) -> IngredientsFunction:
+	from mapFolding.someAssemblyRequired import extractFunctionDef
+	astFunctionDef = extractFunctionDef(astModule, identifierFunctionDef)
+	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
+	return IngredientsFunction(astFunctionDef, LedgerOfImports(astModule))

mapFolding/someAssemblyRequired/_toolboxPython.py

@@ -0,0 +1,76 @@
+from collections.abc import Callable
+from inspect import getsource as inspect_getsource
+from mapFolding.someAssemblyRequired import ast_Identifier, str_nameDOTname
+from os import PathLike
+from pathlib import Path, PurePath
+from types import ModuleType
+from typing import Any, Literal
+import ast
+import importlib
+import importlib.util
+
+# TODO Identify the logic that narrows the type and can help the user during static type checking.
+
+class NodeTourist(ast.NodeVisitor):
+    def __init__(self, findThis, doThat): # type: ignore
+        self.findThis = findThis
+        self.doThat = doThat
+        self.nodeCaptured = None
+
+    def visit(self, node): # type: ignore
+        if self.findThis(node):
+            nodeActionReturn = self.doThat(node) # type: ignore
+            if nodeActionReturn is not None:
+                self.nodeCaptured = nodeActionReturn # type: ignore
+        self.generic_visit(node)
+
+    def captureLastMatch(self, node): # type: ignore
+        """Capture the last matched node that produces a non-None result.
+
+        This method traverses the entire tree starting at the given node
+        and returns the last non-None value produced by applying doThat
+        to a matching node. It will continue traversing after finding a match,
+        and the value captured can be replaced by later matches.
+
+        Parameters:
+            node: The AST node to start traversal from
+
+        Returns:
+            The result of applying doThat to the last matching node that returned
+            a non-None value, or None if no match found or all matches returned None
+        """
+        self.nodeCaptured = None
+        self.visit(node) # type: ignore
+        return self.nodeCaptured
+
+class NodeChanger(ast.NodeTransformer):
+    def __init__(self, findThis, doThat): # type: ignore
+        self.findThis = findThis
+        self.doThat = doThat
+
+    def visit(self, node): # type: ignore
+        if self.findThis(node):
+            return self.doThat(node) # type: ignore
+        return super().visit(node)
+
+def importLogicalPath2Callable(logicalPathModule: str_nameDOTname, identifier: ast_Identifier, packageIdentifierIfRelative: ast_Identifier | None = None) -> Callable[..., Any]:
+    moduleImported: ModuleType = importlib.import_module(logicalPathModule, packageIdentifierIfRelative)
+    return getattr(moduleImported, identifier)
+
+def importPathFilename2Callable(pathFilename: PathLike[Any] | PurePath, identifier: ast_Identifier, moduleIdentifier: ast_Identifier | None = None) -> Callable[..., Any]:
+    pathFilename = Path(pathFilename)
+
+    importlibSpecification = importlib.util.spec_from_file_location(moduleIdentifier or pathFilename.stem, pathFilename)
+    if importlibSpecification is None or importlibSpecification.loader is None: raise ImportError(f"I received\n\t`{pathFilename = }`,\n\t`{identifier = }`, and\n\t`{moduleIdentifier = }`.\n\tAfter loading, \n\t`importlibSpecification` {'is `None`' if importlibSpecification is None else 'has a value'} and\n\t`importlibSpecification.loader` is unknown.")
+
+    moduleImported_jk_hahaha: ModuleType = importlib.util.module_from_spec(importlibSpecification)
+    importlibSpecification.loader.exec_module(moduleImported_jk_hahaha)
+    return getattr(moduleImported_jk_hahaha, identifier)
+
+def parseLogicalPath2astModule(logicalPathModule: str_nameDOTname, packageIdentifierIfRelative: ast_Identifier|None=None, mode:str='exec') -> ast.AST:
+    moduleImported: ModuleType = importlib.import_module(logicalPathModule, packageIdentifierIfRelative)
+    sourcePython: str = inspect_getsource(moduleImported)
+    return ast.parse(sourcePython, mode=mode)
+
+def parsePathFilename2astModule(pathFilename: PathLike[Any] | PurePath, mode:str='exec') -> ast.AST:
+    return ast.parse(Path(pathFilename).read_text(), mode=mode)

mapFolding/someAssemblyRequired/getLLVMforNoReason.py

@@ -12,6 +12,14 @@ The extracted LLVM IR can be valuable for debugging, optimization analysis, or e
 purposes, as it provides a view into how high-level Python code is translated into
 lower-level representations for machine execution.
 
+Example of successful use:
+The LLVM IR for the groundbreaking 2x19 map calculation can be found at:
+mapFolding/reference/jobsCompleted/[2x19]/[2x19].ll
+
+This file demonstrates the low-level optimizations that made this previously
+intractable calculation possible. The IR reveals how the abstract algorithm was
+transformed into efficient machine code through Numba's compilation pipeline.
+
 While originally part of a tighter integration with the code generation pipeline,
 this module now operates as a standalone utility that can be applied to any module
 containing Numba-compiled functions.
@@ -23,7 +31,18 @@ import importlib.util
 import llvmlite.binding
 
 def writeModuleLLVM(pathFilename: Path, identifierCallable: str) -> Path:
-    """Import the generated module directly and get its LLVM IR."""
+    """Import the generated module directly and get its LLVM IR.
+
+    Parameters
+        pathFilename: Path to the Python module file containing the Numba-compiled function
+        identifierCallable: Name of the function within the module to extract LLVM IR from
+
+    Returns
+        Path to the generated .ll file containing the extracted LLVM IR
+
+    For an example of the output, see reference/jobsCompleted/[2x19]/[2x19].ll,
+    which contains the IR for the historically significant 2x19 map calculation.
+    """
     specTarget: ModuleSpec | None = importlib.util.spec_from_file_location("generatedModule", pathFilename)
     if specTarget is None or specTarget.loader is None:
         raise ImportError(f"Could not create module spec or loader for {pathFilename}")

mapFolding/someAssemblyRequired/ingredientsNumba.py

@@ -20,7 +20,8 @@ algorithm implementation into a highly-optimized Numba version.
 """
 
 from collections.abc import Callable, Sequence
-from mapFolding.someAssemblyRequired import ifThis, IngredientsFunction, Make
+from mapFolding.someAssemblyRequired import Make
+from mapFolding.someAssemblyRequired._toolboxContainers import IngredientsFunction
 from numba.core.compiler import CompilerBase as numbaCompilerBase
 from typing import Any, cast, Final, TYPE_CHECKING
 import ast
@@ -71,10 +72,11 @@ parametersNumbaFailEarly: Final[ParametersNumba] = {
 		'no_cfunc_wrapper': False,
 		'no_cpython_wrapper': False,
 		'nopython': True,
-		'parallel': False, }
+		'parallel': False,
+}
 """For a production function: speed is irrelevant, error discovery is paramount, must be compatible with anything downstream."""
 
-parametersNumbaDEFAULT: Final[ParametersNumba] = {
+parametersNumbaDefault: Final[ParametersNumba] = {
 		'_nrt': True,
 		'boundscheck': False,
 		'cache': True,
@@ -90,13 +92,13 @@ parametersNumbaDEFAULT: Final[ParametersNumba] = {
 """Middle of the road: fast, lean, but will talk to non-jitted functions."""
 
 parametersNumbaParallelDEFAULT: Final[ParametersNumba] = {
-		**parametersNumbaDEFAULT,
+		**parametersNumbaDefault,
 		'_nrt': True,
 		'parallel': True, }
 """Middle of the road: fast, lean, but will talk to non-jitted functions."""
 
 parametersNumbaSuperJit: Final[ParametersNumba] = {
-		**parametersNumbaDEFAULT,
+		**parametersNumbaDefault,
 		'no_cfunc_wrapper': True,
 		'no_cpython_wrapper': True, }
 """Speed, no helmet, no talking to non-jitted functions."""
@@ -125,15 +127,6 @@ parametersNumbaMinimum: Final[ParametersNumba] = {
 Z0Z_numbaDataTypeModule = 'numba'
 Z0Z_decoratorCallable = 'jit'
 
-def thisIsNumbaDotJit(Ima: ast.AST) -> bool:
-	return ifThis.isCallNamespace_Identifier(Z0Z_numbaDataTypeModule, Z0Z_decoratorCallable)(Ima)
-
-def thisIsJit(Ima: ast.AST) -> bool:
-	return ifThis.isCall_Identifier(Z0Z_decoratorCallable)(Ima)
-
-def thisIsAnyNumbaJitDecorator(Ima: ast.AST) -> bool:
-	return thisIsNumbaDotJit(Ima) or thisIsJit(Ima)
-
 def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, parametersNumba: ParametersNumba | None = None) -> IngredientsFunction:
 	def Z0Z_UnhandledDecorators(astCallable: ast.FunctionDef) -> ast.FunctionDef:
 		# TODO: more explicit handling of decorators. I'm able to ignore this because I know `algorithmSource` doesn't have any decorators.
@@ -143,7 +136,7 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 			warnings.warn(f"Removed decorator {ast.unparse(decoratorItem)} from {astCallable.name}")
 		return astCallable
 
-	def makeSpecialSignatureForNumba(signatureElement: ast.arg) -> ast.Subscript | ast.Name | None:
+	def makeSpecialSignatureForNumba(signatureElement: ast.arg) -> ast.Subscript | ast.Name | None: # type: ignore
 		if isinstance(signatureElement.annotation, ast.Subscript) and isinstance(signatureElement.annotation.slice, ast.Tuple):
 			annotationShape: ast.expr = signatureElement.annotation.slice.elts[0]
 			if isinstance(annotationShape, ast.Subscript) and isinstance(annotationShape.slice, ast.Tuple):
@@ -162,7 +155,7 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 			ndarrayName = signatureElement.arg
 			Z0Z_hacky_dtype: str = ndarrayName
 			datatype_attr = datatypeAST or Z0Z_hacky_dtype
-			ingredientsFunction.imports.addImportFromStr(datatypeModuleDecorator, datatype_attr)
+			ingredientsFunction.imports.addImportFrom_asStr(datatypeModuleDecorator, datatype_attr)
 			datatypeNumba = ast.Name(id=datatype_attr, ctx=ast.Load())
 
 			return ast.Subscript(value=datatypeNumba, slice=shapeAST, ctx=ast.Load())
@@ -179,9 +172,9 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 		# Efficient translation of Python scalar types to Numba types https://github.com/hunterhogan/mapFolding/issues/8
 		# For now, let Numba infer them.
 		continue
-		signatureElement: ast.Subscript | ast.Name | None = makeSpecialSignatureForNumba(parameter)
-		if signatureElement:
-			list_arg4signature_or_function.append(signatureElement)
+		# signatureElement: ast.Subscript | ast.Name | None = makeSpecialSignatureForNumba(parameter)
+		# if signatureElement:
+		# 	list_arg4signature_or_function.append(signatureElement)
 
 	if ingredientsFunction.astFunctionDef.returns and isinstance(ingredientsFunction.astFunctionDef.returns, ast.Name):
 		theReturn: ast.Name = ingredientsFunction.astFunctionDef.returns
@@ -192,15 +185,15 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 
 	ingredientsFunction.astFunctionDef = Z0Z_UnhandledDecorators(ingredientsFunction.astFunctionDef)
 	if parametersNumba is None:
-		parametersNumba = parametersNumbaDEFAULT
-	listDecoratorKeywords: list[ast.keyword] = [Make.ast_keyword(parameterName, Make.astConstant(parameterValue)) for parameterName, parameterValue in parametersNumba.items()]
+		parametersNumba = parametersNumbaDefault
+	listDecoratorKeywords: list[ast.keyword] = [Make.keyword(parameterName, Make.Constant(parameterValue)) for parameterName, parameterValue in parametersNumba.items()]
 
 	decoratorModule: str = Z0Z_numbaDataTypeModule
 	decoratorCallable: str = Z0Z_decoratorCallable
-	ingredientsFunction.imports.addImportFromStr(decoratorModule, decoratorCallable)
+	ingredientsFunction.imports.addImportFrom_asStr(decoratorModule, decoratorCallable)
 	# Leave this line in so that global edits will change it.
-	astDecorator: ast.Call = Make.astCall(Make.astName(decoratorCallable), list_argsDecorator, listDecoratorKeywords)
-	astDecorator: ast.Call = Make.astCall(Make.astName(decoratorCallable), list_astKeywords=listDecoratorKeywords) # type: ignore[no-redef]
+	astDecorator: ast.Call = Make.Call(Make.Name(decoratorCallable), list_argsDecorator, listDecoratorKeywords)
+	astDecorator: ast.Call = Make.Call(Make.Name(decoratorCallable), list_astKeywords=listDecoratorKeywords)
 
 	ingredientsFunction.astFunctionDef.decorator_list = [astDecorator]
 	return ingredientsFunction