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

mapFolding/someAssemblyRequired/_toolboxContainers.py

@@ -7,9 +7,10 @@ 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 mapFolding.someAssemblyRequired import ImaAnnotationType, ast_Identifier, be, Make, parseLogicalPath2astModule, str_nameDOTname
+from mapFolding.theSSOT import callableDispatcherHARDCODED, The
 from pathlib import Path, PurePosixPath
+from typing import Literal
 from Z0Z_tools import updateExtendPolishDictionaryLists
 import ast
 import dataclasses
@@ -36,11 +37,45 @@ class LedgerOfImports:
 			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 addImport_asStr(self, moduleWithLogicalPath: str_nameDOTname) -> None:
+		self.listImport.append(moduleWithLogicalPath)
+
+	# def addImportFrom_asStr(self, moduleWithLogicalPath: str_nameDOTname, name: ast_Identifier, asname: ast_Identifier | None = None) -> None:
+	# 	self.dictionaryImportFrom[moduleWithLogicalPath].append((name, asname))
+
+	def addImportFrom_asStr(self, moduleWithLogicalPath: str_nameDOTname, name: ast_Identifier, asname: ast_Identifier | None = None) -> None:
+		if moduleWithLogicalPath not in self.dictionaryImportFrom:
+			self.dictionaryImportFrom[moduleWithLogicalPath] = []
+		self.dictionaryImportFrom[moduleWithLogicalPath].append((name, asname))
+
+	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:
+		if moduleWithLogicalPath is None:
+			raise SyntaxError(f"I received `{moduleWithLogicalPath = }`, but it must be the name of a module.")
+		if moduleWithLogicalPath in self.dictionaryImportFrom:
+			"""
+			name, 			asname				  	Meaning
+			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
+			None, 			None					: remove all matches for the module
+			"""
+			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:
+					# Remove exact matches for the module
+					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())
@@ -49,13 +84,14 @@ class LedgerOfImports:
 
 	def makeList_ast(self) -> list[ast.ImportFrom | ast.Import]:
 		listImportFrom: list[ast.ImportFrom] = []
-		for moduleIdentifier, listOfNameTuples in sorted(self.dictionaryImportFrom.items()):
+		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))
-			listImportFrom.append(Make.ImportFrom(moduleIdentifier, list_alias))
-		list_astImport: list[ast.Import] = [Make.Import(moduleIdentifier) for moduleIdentifier in sorted(set(self.listImport))]
+			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:
@@ -158,6 +194,19 @@ class IngredientsModule:
 			else:
 				raise ValueError(f"I received `{type(allegedIngredientsFunction) = }`, but I can only accept `{IngredientsFunction}`.")
 
+	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)
+
 	@property
 	def list_astImportImportFrom(self) -> list[ast.Import | ast.ImportFrom]:
 		"""List of `ast.Import` and `ast.ImportFrom` statements."""
@@ -299,8 +348,36 @@ theLogicalPathModuleDispatcherSynthetic: str = '.'.join([The.packageName, The.mo
 		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))
+dummyAssign = Make.Assign([Make.Name("dummyTarget")], Make.Constant(None))
+dummySubscript = Make.Subscript(Make.Name("dummy"), Make.Name("slice"))
+dummyTuple = Make.Tuple([Make.Name("dummyElement")])
+
+@dataclasses.dataclass
+class ShatteredDataclass:
+	countingVariableAnnotation: ImaAnnotationType
+	"""Type annotation for the counting variable extracted from the dataclass."""
+	countingVariableName: ast.Name
+	"""AST name node representing the counting variable identifier."""
+	field2AnnAssign: dict[ast_Identifier, ast.AnnAssign] = dataclasses.field(default_factory=dict)
+	"""Maps field names to their corresponding AST call expressions."""
+	Z0Z_field2AnnAssign: dict[ast_Identifier, tuple[ast.AnnAssign, str]] = dataclasses.field(default_factory=dict)
+	fragments4AssignmentOrParameters: ast.Tuple = dummyTuple
+	"""AST tuple used as target for assignment to capture returned fragments."""
+	ledger: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
+	"""Import records for the dataclass and its constituent parts."""
+	list_argAnnotated4ArgumentsSpecification: list[ast.arg] = dataclasses.field(default_factory=list)
+	"""Function argument nodes with annotations for parameter specification."""
+	list_keyword_field__field4init: list[ast.keyword] = dataclasses.field(default_factory=list)
+	"""Keyword arguments for dataclass initialization with field=field format."""
+	listAnnotations: list[ImaAnnotationType] = dataclasses.field(default_factory=list)
+	"""Type annotations for each dataclass field."""
+	listName4Parameters: list[ast.Name] = dataclasses.field(default_factory=list)
+	"""Name nodes for each dataclass field used as function parameters."""
+	listUnpack: list[ast.AnnAssign] = dataclasses.field(default_factory=list)
+	"""Annotated assignment statements to extract fields from dataclass."""
+	map_stateDOTfield2Name: dict[ast.expr, ast.Name] = dataclasses.field(default_factory=dict)
+	"""Maps AST expressions to Name nodes for find-replace operations."""
+	repack: ast.Assign = dummyAssign
+	"""AST assignment statement that reconstructs the original dataclass instance."""
+	signatureReturnAnnotation: ast.Subscript = dummySubscript
+	"""tuple-based return type annotation for function definitions."""

mapFolding/someAssemblyRequired/_toolboxPython.py

@@ -1,57 +1,43 @@
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
 from inspect import getsource as inspect_getsource
-from mapFolding.someAssemblyRequired import ast_Identifier, str_nameDOTname
+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
+from typing import Any, cast, Generic, TypeGuard
 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
+class NodeTourist(ast.NodeVisitor, Generic[个]):
+    def __init__(self, findThis: Callable[[个], TypeGuard[个] | bool], doThat: Callable[[个], 个 | None]) -> None:
         self.findThis = findThis
         self.doThat = doThat
-        self.nodeCaptured = None
+        self.nodeCaptured: 个 | None = None
 
-    def visit(self, node): # type: ignore
+    def visit(self, node: 个) -> None: # pyright: ignore [reportGeneralTypeIssues]
         if self.findThis(node):
-            nodeActionReturn = self.doThat(node) # type: ignore
+            nodeActionReturn = self.doThat(node)
             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
+                self.nodeCaptured = nodeActionReturn
+        self.generic_visit(cast(ast.AST, node))
 
-        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
-        """
+    def captureLastMatch(self, node: 个) -> 个 | None: # pyright: ignore [reportGeneralTypeIssues]
         self.nodeCaptured = None
-        self.visit(node) # type: ignore
+        self.visit(node)
         return self.nodeCaptured
 
-class NodeChanger(ast.NodeTransformer):
-    def __init__(self, findThis, doThat): # type: ignore
+class NodeChanger(ast.NodeTransformer, Generic[个]):
+    def __init__(self, findThis: Callable[[个], bool], doThat: Callable[[个], Sequence[个] | 个 | None]) -> None:
         self.findThis = findThis
         self.doThat = doThat
 
-    def visit(self, node): # type: ignore
+    def visit(self, node: 个) -> Sequence[个] | 个 | None: # pyright: ignore [reportGeneralTypeIssues]
         if self.findThis(node):
-            return self.doThat(node) # type: ignore
-        return super().visit(node)
+            return self.doThat(node)
+        return super().visit(cast(ast.AST, node))
 
 def importLogicalPath2Callable(logicalPathModule: str_nameDOTname, identifier: ast_Identifier, packageIdentifierIfRelative: ast_Identifier | None = None) -> Callable[..., Any]:
     moduleImported: ModuleType = importlib.import_module(logicalPathModule, packageIdentifierIfRelative)

mapFolding/someAssemblyRequired/getLLVMforNoReason.py

@@ -18,9 +18,9 @@ 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.
+transformed into efficient machine code through Numba's compilation assembly-line.
 
-While originally part of a tighter integration with the code generation pipeline,
+While originally part of a tighter integration with the code generation assembly-line,
 this module now operates as a standalone utility that can be applied to any module
 containing Numba-compiled functions.
 """

mapFolding/someAssemblyRequired/newInliner.py

@@ -0,0 +1,22 @@
+from collections.abc import Callable
+from copy import deepcopy
+from mapFolding.someAssemblyRequired import ast_Identifier, RecipeSynthesizeFlow, Then, be, ifThis, DOT, 又, NodeChanger
+from mapFolding.someAssemblyRequired.transformationTools import makeDictionary4InliningFunction, makeDictionaryFunctionDef
+from typing import cast
+import ast
+
+def inlineFunctionDef(astFunctionDef: ast.FunctionDef, dictionary4Inlining: dict[ast_Identifier, ast.FunctionDef]) -> ast.FunctionDef:
+
+	return astFunctionDef
+
+# Test code
+testFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()
+dictionary4Inlining: dict[ast_Identifier, ast.FunctionDef] = makeDictionary4InliningFunction(
+	testFlow.sourceCallableSequential,
+	(dictionaryFunctionDef := makeDictionaryFunctionDef(testFlow.source_astModule)))
+
+astFunctionDef = dictionaryFunctionDef[testFlow.sourceCallableSequential]
+
+astFunctionDefTransformed = inlineFunctionDef(
+	astFunctionDef,
+	dictionary4Inlining)

mapFolding/someAssemblyRequired/synthesizeNumbaJob.py

@@ -1,16 +1,15 @@
 """Synthesize one file to compute `foldsTotal` of `mapShape`."""
-from mapFolding.someAssemblyRequired import ast_Identifier, be, ifThis, Make, NodeChanger, NodeTourist, parsePathFilename2astModule, str_nameDOTname, Then, write_astModule, 又
-from mapFolding.someAssemblyRequired.ingredientsNumba import decorateCallableWithNumba, ParametersNumba, parametersNumbaDefault
-from mapFolding.someAssemblyRequired.synthesizeNumbaFlow import theNumbaFlow
-from mapFolding.someAssemblyRequired.transformDataStructures import makeInitializedComputationState, shatter_dataclassesDOTdataclass, ShatteredDataclass
-from mapFolding.someAssemblyRequired._toolboxContainers import astModuleToIngredientsFunction, IngredientsFunction, IngredientsModule, LedgerOfImports
-from mapFolding.filesystem import getFilenameFoldsTotal, getPathFilenameFoldsTotal, getPathRootJobDEFAULT
-from mapFolding.theSSOT import ComputationState, The
-from pathlib import Path, PurePosixPath
+from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal
+from mapFolding.someAssemblyRequired import ast_Identifier, be, ifThis, Make, NodeChanger, Then, IngredientsFunction, IngredientsModule, LedgerOfImports
+from mapFolding.someAssemblyRequired.toolboxNumba import RecipeJob, SpicesJobNumba, decorateCallableWithNumba
+from mapFolding.someAssemblyRequired.transformationTools import astModuleToIngredientsFunction, extractFunctionDef, write_astModule
+from mapFolding.someAssemblyRequired.transformationTools import makeInitializedComputationState
+from mapFolding.theSSOT import The, raiseIfNoneGitHubIssueNumber3
+from mapFolding.oeis import getFoldsTotalKnown
 from typing import cast
 from Z0Z_tools import autoDecodingRLE
+from pathlib import PurePosixPath
 import ast
-import dataclasses
 
 list_IdentifiersNotUsedAllHARDCODED = ['concurrencyLimit', 'foldsTotal', 'mapShape',]
 list_IdentifiersNotUsedParallelSequentialHARDCODED = ['indexLeaf']
@@ -22,105 +21,14 @@ list_IdentifiersStaticValuesHARDCODED = ['dimensionsTotal', 'leavesTotal',]
 
 list_IdentifiersNotUsedHARDCODED = list_IdentifiersStaticValuesHARDCODED + list_IdentifiersReplacedHARDCODED + list_IdentifiersNotUsedAllHARDCODED + list_IdentifiersNotUsedParallelSequentialHARDCODED + list_IdentifiersNotUsedSequentialHARDCODED
 
-@dataclasses.dataclass
-class Z0Z_RecipeJob:
-	state: ComputationState
-	# TODO create function to calculate `foldsTotalEstimated`
-	foldsTotalEstimated: int = 0
-	useNumbaProgressBar: bool = True
-	numbaProgressBarIdentifier: ast_Identifier = 'ProgressBarGroupsOfFolds'
-	shatteredDataclass: ShatteredDataclass = dataclasses.field(default=None, init=True) # type: ignore[assignment, reportAssignmentType]
-
-	# ========================================
-	# Source
-	source_astModule = parsePathFilename2astModule(theNumbaFlow.pathFilenameSequential)
-	sourceCountCallable: ast_Identifier = theNumbaFlow.callableSequential
-
-	sourceLogicalPathModuleDataclass: str_nameDOTname = theNumbaFlow.logicalPathModuleDataclass
-	sourceDataclassIdentifier: ast_Identifier = theNumbaFlow.dataclassIdentifier
-	sourceDataclassInstance: ast_Identifier = theNumbaFlow.dataclassInstance
-
-	sourcePathPackage: PurePosixPath | None = theNumbaFlow.pathPackage
-	sourcePackageIdentifier: ast_Identifier | None = theNumbaFlow.packageIdentifier
-
-	# ========================================
-	# Filesystem (names of physical objects)
-	pathPackage: PurePosixPath | None = None
-	pathModule: PurePosixPath | None = PurePosixPath(getPathRootJobDEFAULT())
-	""" `pathModule` will override `pathPackage` and `logicalPathRoot`."""
-	fileExtension: str = theNumbaFlow.fileExtension
-	pathFilenameFoldsTotal: PurePosixPath = dataclasses.field(default=None, init=True) # type: ignore[assignment, reportAssignmentType]
-
-	# ========================================
-	# Logical identifiers (as opposed to physical identifiers)
-	# ========================================
-	packageIdentifier: ast_Identifier | None = None
-	logicalPathRoot: str_nameDOTname | None = None
-	""" `logicalPathRoot` likely corresponds to a physical filesystem directory."""
-	moduleIdentifier: ast_Identifier = dataclasses.field(default=None, init=True) # type: ignore[assignment, reportAssignmentType]
-	countCallable: ast_Identifier = sourceCountCallable
-	dataclassIdentifier: ast_Identifier | None = sourceDataclassIdentifier
-	dataclassInstance: ast_Identifier | None = sourceDataclassInstance
-	logicalPathModuleDataclass: str_nameDOTname | None = sourceLogicalPathModuleDataclass
-
-	def _makePathFilename(self,
-			pathRoot: PurePosixPath | None = None,
-			logicalPathINFIX: str_nameDOTname | None = None,
-			filenameStem: str | None = None,
-			fileExtension: str | None = None,
-			) -> PurePosixPath:
-		if pathRoot is None:
-			pathRoot = self.pathPackage or PurePosixPath(Path.cwd())
-		if logicalPathINFIX:
-			whyIsThisStillAThing: list[str] = logicalPathINFIX.split('.')
-			pathRoot = pathRoot.joinpath(*whyIsThisStillAThing)
-		if filenameStem is None:
-			filenameStem = self.moduleIdentifier
-		if fileExtension is None:
-			fileExtension = self.fileExtension
-		filename: str = filenameStem + fileExtension
-		return pathRoot.joinpath(filename)
-
-	@property
-	def pathFilenameModule(self) -> PurePosixPath:
-		if self.pathModule is None:
-			return self._makePathFilename()
-		else:
-			return self._makePathFilename(pathRoot=self.pathModule, logicalPathINFIX=None)
-
-	def __post_init__(self):
-		pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(self.state.mapShape))
-
-		if self.moduleIdentifier is None:
-			self.moduleIdentifier = pathFilenameFoldsTotal.stem
-
-		if self.pathFilenameFoldsTotal is None:
-			self.pathFilenameFoldsTotal = pathFilenameFoldsTotal
-
-		if self.shatteredDataclass is None and self.logicalPathModuleDataclass and self.dataclassIdentifier and self.dataclassInstance:
-			self.shatteredDataclass = shatter_dataclassesDOTdataclass(self.logicalPathModuleDataclass, self.dataclassIdentifier, self.dataclassInstance)
-
-	# ========================================
-	# Fields you probably don't need =================================
-	# Dispatcher =================================
-	sourceDispatcherCallable: ast_Identifier = theNumbaFlow.callableDispatcher
-	dispatcherCallable: ast_Identifier = sourceDispatcherCallable
-	# Parallel counting =================================
-	sourceDataclassInstanceTaskDistribution: ast_Identifier = theNumbaFlow.dataclassInstanceTaskDistribution
-	sourceConcurrencyManagerNamespace: ast_Identifier = theNumbaFlow.concurrencyManagerNamespace
-	sourceConcurrencyManagerIdentifier: ast_Identifier = theNumbaFlow.concurrencyManagerIdentifier
-	dataclassInstanceTaskDistribution: ast_Identifier = sourceDataclassInstanceTaskDistribution
-	concurrencyManagerNamespace: ast_Identifier = sourceConcurrencyManagerNamespace
-	concurrencyManagerIdentifier: ast_Identifier = sourceConcurrencyManagerIdentifier
-
-def addLauncherNumbaProgress(ingredientsModule: IngredientsModule, ingredientsFunction: IngredientsFunction, job: Z0Z_RecipeJob) -> IngredientsModule:
+def addLauncherNumbaProgress(ingredientsModule: IngredientsModule, ingredientsFunction: IngredientsFunction, job: RecipeJob, spices: SpicesJobNumba) -> tuple[IngredientsModule, IngredientsFunction]:
 
 	linesLaunch: str = f"""
 if __name__ == '__main__':
 	with ProgressBar(total={job.foldsTotalEstimated}, update_interval=2) as statusUpdate:
 		{job.countCallable}(statusUpdate)
 		foldsTotal = statusUpdate.n * {job.state.leavesTotal}
-		print('map {job.state.mapShape} =', foldsTotal)
+		print('\\nmap {job.state.mapShape} =', foldsTotal)
 		writeStream = open('{job.pathFilenameFoldsTotal.as_posix()}', 'w')
 		writeStream.write(str(foldsTotal))
 		writeStream.close()
@@ -130,19 +38,19 @@ if __name__ == '__main__':
 	ingredientsModule.imports.addImportFrom_asStr('numba_progress', numba_progressPythonClass)
 	ingredientsModule.imports.addImportFrom_asStr('numba_progress', numba_progressNumbaType)
 
-	ast_argNumbaProgress = ast.arg(arg=job.numbaProgressBarIdentifier, annotation=ast.Name(id=numba_progressPythonClass, ctx=ast.Load()))
+	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))
-	doThat = Then.replaceWith(Make.Expr(Make.Call(Make.Attribute(Make.Name(job.numbaProgressBarIdentifier),'update'),[Make.Constant(1)])))
-	countWithProgressBar = NodeChanger(findThis, doThat)
+	doThat = Then.replaceWith(Make.Expr(Make.Call(Make.Attribute(Make.Name(spices.numbaProgressBarIdentifier),'update'),[Make.Constant(1)])))
+	countWithProgressBar = NodeChanger(findThis, doThat) # type: ignore
 	countWithProgressBar.visit(ingredientsFunction.astFunctionDef)
 
 	ingredientsModule.appendLauncher(ast.parse(linesLaunch))
 
-	return ingredientsModule
+	return ingredientsModule, ingredientsFunction
 
-def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: IngredientsFunction, job: Z0Z_RecipeJob) -> IngredientsFunction:
+def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: IngredientsFunction, job: RecipeJob) -> IngredientsFunction:
 	ingredientsFunction.imports.update(job.shatteredDataclass.ledger)
 
 	list_IdentifiersNotUsed = list_IdentifiersNotUsedHARDCODED
@@ -158,7 +66,6 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 					case 'scalar':
 						ImaAnnAssign.value.args[0].value = int(job.state.__dict__[ast_arg.arg])  # type: ignore
 					case 'array':
-						# print(ast.dump(ImaAnnAssign))
 						dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[ast_arg.arg], addSpaces=True)
 						dataAs_astExpr: ast.expr = cast(ast.Expr, ast.parse(dataAsStrRLE).body[0]).value
 						ImaAnnAssign.value.args = [dataAs_astExpr]  # type: ignore
@@ -180,9 +87,11 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 	ast.fix_missing_locations(ingredientsFunction.astFunctionDef)
 	return ingredientsFunction
 
-def makeJobNumba(job: Z0Z_RecipeJob, parametersNumba: ParametersNumba = parametersNumbaDefault):
+def makeJobNumba(job: RecipeJob, spices: SpicesJobNumba):
 		# get the raw ingredients: data and the algorithm
-	ingredientsCount: IngredientsFunction = astModuleToIngredientsFunction(job.source_astModule, job.countCallable)
+	astFunctionDef = extractFunctionDef(job.source_astModule, job.countCallable)
+	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
+	ingredientsCount: IngredientsFunction = IngredientsFunction(astFunctionDef, LedgerOfImports())
 
 	# Change the return so you can dynamically determine which variables are not used
 	removeReturnStatement = NodeChanger(be.Return, Then.removeIt)
@@ -200,18 +109,54 @@ def makeJobNumba(job: Z0Z_RecipeJob, parametersNumba: ParametersNumba = paramete
 	for identifier in list_IdentifiersStaticValues:
 		findThis = ifThis.isName_Identifier(identifier)
 		doThat = Then.replaceWith(Make.Constant(int(job.state.__dict__[identifier])))
-		NodeChanger(findThis, doThat).visit(ingredientsCount.astFunctionDef)
+		NodeChanger(findThis, doThat).visit(ingredientsCount.astFunctionDef) # type: ignore
 
 	# This launcher eliminates the use of one identifier, so run it now and you can dynamically determine which variables are not used
 	ingredientsModule = IngredientsModule()
-	ingredientsModule = addLauncherNumbaProgress(ingredientsModule, ingredientsCount, job)
-	parametersNumba['nogil'] = True
+	if spices.useNumbaProgressBar:
+		ingredientsModule, ingredientsCount = addLauncherNumbaProgress(ingredientsModule, ingredientsCount, job, spices)
+		spices.parametersNumba['nogil'] = True
 
 	ingredientsCount = move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsCount, job)
 
+	Z0Z_Identifier = 'DatatypeLeavesTotal'
+	Z0Z_type = 'uint8'
+	ingredientsModule.imports.addImportFrom_asStr('numba', Z0Z_type)
+	Z0Z_module = 'typing'
+	Z0Z_annotation = 'TypeAlias'
+	ingredientsModule.imports.addImportFrom_asStr(Z0Z_module, Z0Z_annotation)
+	Z0Z_statement = Make.AnnAssign(Make.Name(Z0Z_Identifier, ast.Store()), Make.Name(Z0Z_annotation), Make.Name(Z0Z_type))
+	ingredientsModule.appendPrologue(statement=Z0Z_statement)
+
+	Z0Z_Identifier = 'DatatypeElephino'
+	Z0Z_type = 'int16'
+	ingredientsModule.imports.addImportFrom_asStr('numba', Z0Z_type)
+	Z0Z_module = 'typing'
+	Z0Z_annotation = 'TypeAlias'
+	ingredientsModule.imports.addImportFrom_asStr(Z0Z_module, Z0Z_annotation)
+	Z0Z_statement = Make.AnnAssign(Make.Name(Z0Z_Identifier, ast.Store()), Make.Name(Z0Z_annotation), Make.Name(Z0Z_type))
+	ingredientsModule.appendPrologue(statement=Z0Z_statement)
+
+	ingredientsCount.imports.removeImportFromModule('mapFolding.theSSOT')
+	Z0Z_module = 'numpy'
+	Z0Z_asname = 'Array1DLeavesTotal'
+	ingredientsCount.imports.removeImportFrom(Z0Z_module, None, Z0Z_asname)
+	Z0Z_type_name = 'uint8'
+	ingredientsCount.imports.addImportFrom_asStr(Z0Z_module, Z0Z_type_name, Z0Z_asname)
+	Z0Z_asname = 'Array1DElephino'
+	ingredientsCount.imports.removeImportFrom(Z0Z_module, None, Z0Z_asname)
+	Z0Z_type_name = 'int16'
+	ingredientsCount.imports.addImportFrom_asStr(Z0Z_module, Z0Z_type_name, Z0Z_asname)
+	Z0Z_asname = 'Array3D'
+	ingredientsCount.imports.removeImportFrom(Z0Z_module, None, Z0Z_asname)
+	Z0Z_type_name = 'uint8'
+	ingredientsCount.imports.addImportFrom_asStr(Z0Z_module, Z0Z_type_name, Z0Z_asname)
+
+	from numpy import int16 as Array1DLeavesTotal, int16 as Array1DElephino, int16 as Array3D
+
 	ingredientsCount.astFunctionDef.decorator_list = [] # TODO low-priority, handle this more elegantly
 	# TODO when I add the function signature in numba style back to the decorator, the logic needs to handle `ProgressBarType:`
-	ingredientsCount = decorateCallableWithNumba(ingredientsCount, parametersNumba)
+	ingredientsCount = decorateCallableWithNumba(ingredientsCount, spices.parametersNumba)
 
 	ingredientsModule.appendIngredientsFunction(ingredientsCount)
 
@@ -243,5 +188,9 @@ def makeJobNumba(job: Z0Z_RecipeJob, parametersNumba: ParametersNumba = paramete
 if __name__ == '__main__':
 	mapShape = (6,6)
 	state = makeInitializedComputationState(mapShape)
-	aJob = Z0Z_RecipeJob(state)
-	makeJobNumba(aJob)
+	foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal
+	pathModule = PurePosixPath(The.pathPackage, 'jobs')
+	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
+	aJob = RecipeJob(state, foldsTotalEstimated, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
+	spices = SpicesJobNumba()
+	makeJobNumba(aJob, spices)