mapFolding 0.9.0__py3-none-any.whl → 0.9.2__py3-none-any.whl

mapFolding/someAssemblyRequired/_toolboxAntecedents.py

@@ -2,17 +2,22 @@
 AST Node Predicate and Access Utilities for Pattern Matching and Traversal
 
 This module provides utilities for accessing and matching AST nodes in a consistent way.
-It contains two primary classes:
+It contains three primary classes:
 
 1. DOT: Provides consistent accessor methods for AST node attributes across different
    node types, simplifying the access to node properties.
 
-2. ifThis: Contains predicate functions for matching AST nodes based on various criteria,
+2. be: Offers type-guard functions that verify AST node types, enabling safe type
+   narrowing for static type checking and improving code safety.
+
+3. ifThis: Contains predicate functions for matching AST nodes based on various criteria,
    enabling precise targeting of nodes for analysis or transformation.
 
 These utilities form the foundation of the pattern-matching component in the AST
 manipulation framework, working in conjunction with the NodeChanger and NodeTourist
-classes to enable precise and targeted code transformations.
+classes to enable precise and targeted code transformations. Together, they implement
+a declarative approach to AST manipulation that separates node identification (ifThis),
+type verification (be), and data access (DOT).
 """
 
 from collections.abc import Callable
@@ -26,6 +31,7 @@ from mapFolding.someAssemblyRequired import (
 	astClassHasDOTvalue_expr,
 	astClassOptionallyHasDOTnameNotName,
 	astClassHasDOTvalue_exprNone,
+	ImaCallToName,
 )
 from typing import Any, overload, TypeGuard
 import ast
@@ -65,9 +71,17 @@ class DOT:
 	@staticmethod
 	def attr(node: ast.Attribute) -> ast_Identifier:
 		return node.attr
+
+	@staticmethod
+	@overload
+	def func(node: ImaCallToName) -> ast.Name:...
+	@staticmethod
+	@overload
+	def func(node: ast.Call) -> ast.expr:...
 	@staticmethod
-	def func(node: ast.Call) -> ast.expr:
+	def func(node: ast.Call | ImaCallToName) -> ast.expr | ast.Name:
 		return node.func
+
 	@staticmethod
 	def id(node: ast.Name) -> ast_Identifier:
 		return node.id
@@ -111,6 +125,75 @@ class DOT:
 	def value(node: astClassHasDOTvalue) -> Any | ast.expr | bool | None:
 		return node.value
 
+class be:
+	"""
+	Provide type-guard functions for safely verifying AST node types during manipulation.
+
+	The be class contains static methods that perform runtime type verification of AST nodes,
+	returning TypeGuard results that enable static type checkers to narrow node types in
+	conditional branches. These type-guards:
+
+	1. Improve code safety by preventing operations on incompatible node types
+	2. Enable IDE tooling to provide better autocompletion and error detection
+	3. Document expected node types in a way that's enforced by the type system
+	4. Support pattern-matching workflows where node types must be verified before access
+
+	When used with conditional statements, these type-guards allow for precise,
+	type-safe manipulation of AST nodes while maintaining full static type checking
+	capabilities, even in complex transformation scenarios.
+	"""
+	@staticmethod
+	def AnnAssign(node: ast.AST) -> TypeGuard[ast.AnnAssign]:
+		return isinstance(node, ast.AnnAssign)
+
+	@staticmethod
+	def arg(node: ast.AST) -> TypeGuard[ast.arg]:
+		return isinstance(node, ast.arg)
+
+	@staticmethod
+	def Assign(node: ast.AST) -> TypeGuard[ast.Assign]:
+		return isinstance(node, ast.Assign)
+
+	@staticmethod
+	def Attribute(node: ast.AST) -> TypeGuard[ast.Attribute]:
+		return isinstance(node, ast.Attribute)
+
+	@staticmethod
+	def AugAssign(node: ast.AST) -> TypeGuard[ast.AugAssign]:
+		return isinstance(node, ast.AugAssign)
+
+	@staticmethod
+	def Call(node: ast.AST) -> TypeGuard[ast.Call]:
+		return isinstance(node, ast.Call)
+
+	@staticmethod
+	def ClassDef(node: ast.AST) -> TypeGuard[ast.ClassDef]:
+		return isinstance(node, ast.ClassDef)
+
+	@staticmethod
+	def FunctionDef(node: ast.AST) -> TypeGuard[ast.FunctionDef]:
+		return isinstance(node, ast.FunctionDef)
+
+	@staticmethod
+	def keyword(node: ast.AST) -> TypeGuard[ast.keyword]:
+		return isinstance(node, ast.keyword)
+
+	@staticmethod
+	def Name(node: ast.AST) -> TypeGuard[ast.Name]:
+		return isinstance(node, ast.Name)
+
+	@staticmethod
+	def Return(node: ast.AST) -> TypeGuard[ast.Return]:
+		return isinstance(node, ast.Return)
+
+	@staticmethod
+	def Starred(node: ast.AST) -> TypeGuard[ast.Starred]:
+		return isinstance(node, ast.Starred)
+
+	@staticmethod
+	def Subscript(node: ast.AST) -> TypeGuard[ast.Subscript]:
+		return isinstance(node, ast.Subscript)
+
 class ifThis:
 	"""
 	Provide predicate functions for matching and filtering AST nodes based on various criteria.
@@ -135,41 +218,41 @@ class ifThis:
 	@staticmethod
 	def is_arg_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.arg] | bool]:
 		"""see also `isArgument_Identifier`"""
-		return lambda node: isinstance(node, ast.arg) and ifThis._Identifier(identifier)(DOT.arg(node))
+		return lambda node: be.arg(node) and ifThis._Identifier(identifier)(DOT.arg(node))
 	@staticmethod
 	def is_keyword_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.keyword] | bool]:
 		"""see also `isArgument_Identifier`"""
-		return lambda node: isinstance(node, ast.keyword) and ifThis._Identifier(identifier)(DOT.arg(node))
+		return lambda node: be.keyword(node) and ifThis._Identifier(identifier)(DOT.arg(node))
 
 	@staticmethod
 	def isAnnAssign_targetIs(targetPredicate: Callable[[ast.expr], TypeGuard[ast.expr] | bool]) -> Callable[[ast.AST], TypeGuard[ast.AnnAssign] | bool]:
 		def workhorse(node: ast.AST) -> TypeGuard[ast.AnnAssign] | bool:
-			return isinstance(node, ast.AnnAssign) and targetPredicate(DOT.target(node))
+			return be.AnnAssign(node) and targetPredicate(DOT.target(node))
 		return workhorse
 
 	@staticmethod
 	def isArgument_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.arg | ast.keyword] | bool]:
-		return lambda node: (isinstance(node, ast.arg) or isinstance(node, ast.keyword)) and ifThis._Identifier(identifier)(DOT.arg(node))
+		return lambda node: (be.arg(node) or be.keyword(node)) and ifThis._Identifier(identifier)(DOT.arg(node))
 
 	@staticmethod
 	def isAssignAndTargets0Is(targets0Predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], TypeGuard[ast.AnnAssign] | bool]:
 		"""node is Assign and node.targets[0] matches `targets0Predicate`."""
-		return lambda node: isinstance(node, ast.Assign) and targets0Predicate(node.targets[0])
+		return lambda node: be.Assign(node) and targets0Predicate(node.targets[0])
 	@staticmethod
 	def isAssignAndValueIs(valuePredicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], TypeGuard[ast.Assign] | bool]:
 		"""node is ast.Assign and node.value matches `valuePredicate`. """
-		return lambda node: isinstance(node, ast.Assign) and valuePredicate(DOT.value(node))
+		return lambda node: be.Assign(node) and valuePredicate(DOT.value(node))
 
 	@staticmethod
 	def isAttribute_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Attribute] | bool]:
 		"""node is `ast.Attribute` and the top-level `ast.Name` is `identifier`"""
 		def workhorse(node: ast.AST) -> TypeGuard[ast.Attribute]:
-			return isinstance(node, ast.Attribute) and ifThis._nested_Identifier(identifier)(DOT.value(node))
+			return be.Attribute(node) and ifThis._nested_Identifier(identifier)(DOT.value(node))
 		return workhorse
 	@staticmethod
 	def isAttributeName(node: ast.AST) -> TypeGuard[ast.Attribute]:
 		""" Displayed as Name.attribute."""
-		return isinstance(node, ast.Attribute) and isinstance(DOT.value(node), ast.Name)
+		return be.Attribute(node) and be.Name(DOT.value(node))
 	@staticmethod
 	def isAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Attribute] | bool]:
 		return lambda node: ifThis.isAttributeName(node) and ifThis.isName_Identifier(namespace)(DOT.value(node)) and ifThis._Identifier(identifier)(DOT.attr(node))
@@ -177,42 +260,47 @@ class ifThis:
 	@staticmethod
 	def isAugAssign_targetIs(targetPredicate: Callable[[ast.expr], TypeGuard[ast.expr] | bool]) -> Callable[[ast.AST], TypeGuard[ast.AugAssign] | bool]:
 		def workhorse(node: ast.AST) -> TypeGuard[ast.AugAssign] | bool:
-			return isinstance(node, ast.AugAssign) and targetPredicate(DOT.target(node))
+			return be.AugAssign(node) and targetPredicate(DOT.target(node))
 		return workhorse
 
 	@staticmethod
-	def isCall_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Call] | bool]:
-		return lambda node: isinstance(node, ast.Call) and ifThis.isName_Identifier(identifier)(DOT.func(node))
+	def isCall_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ImaCallToName] | bool]:
+		def workhorse(node: ast.AST) -> TypeGuard[ImaCallToName] | bool:
+			return ifThis.isCallToName(node) and ifThis._Identifier(identifier)(DOT.id(DOT.func(node)))
+		return workhorse
+
 	@staticmethod
 	def isCallAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Call] | bool]:
-		return lambda node: isinstance(node, ast.Call) and ifThis.isAttributeNamespace_Identifier(namespace, identifier)(DOT.func(node))
+		def workhorse(node: ast.AST) -> TypeGuard[ast.Call] | bool:
+			return be.Call(node) and ifThis.isAttributeNamespace_Identifier(namespace, identifier)(DOT.func(node))
+		return workhorse
 	@staticmethod
-	def isCallToName(node: ast.AST) -> TypeGuard[ast.Call]:
-		return isinstance(node, ast.Call) and isinstance(DOT.func(node), ast.Name)
+	def isCallToName(node: ast.AST) -> TypeGuard[ImaCallToName]:
+		return be.Call(node) and be.Name(DOT.func(node))
 
 	@staticmethod
 	def isClassDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.ClassDef] | bool]:
-		return lambda node: isinstance(node, ast.ClassDef) and ifThis._Identifier(identifier)(DOT.name(node))
+		return lambda node: be.ClassDef(node) and ifThis._Identifier(identifier)(DOT.name(node))
 
 	@staticmethod
 	def isFunctionDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.FunctionDef] | bool]:
-		return lambda node: isinstance(node, ast.FunctionDef) and ifThis._Identifier(identifier)(DOT.name(node))
+		return lambda node: be.FunctionDef(node) and ifThis._Identifier(identifier)(DOT.name(node))
 
 	@staticmethod
 	def isName_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Name] | bool]:
-		return lambda node: isinstance(node, ast.Name) and ifThis._Identifier(identifier)(DOT.id(node))
+		return lambda node: be.Name(node) and ifThis._Identifier(identifier)(DOT.id(node))
 
 	@staticmethod
 	def isStarred_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Starred] | bool]:
 		"""node is `ast.Starred` and the top-level `ast.Name` is `identifier`"""
 		def workhorse(node: ast.AST) -> TypeGuard[ast.Starred]:
-			return isinstance(node, ast.Starred) and ifThis._nested_Identifier(identifier)(DOT.value(node))
+			return be.Starred(node) and ifThis._nested_Identifier(identifier)(DOT.value(node))
 		return workhorse
 	@staticmethod
 	def isSubscript_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Subscript] | bool]:
 		"""node is `ast.Subscript` and the top-level `ast.Name` is `identifier`"""
 		def workhorse(node: ast.AST) -> TypeGuard[ast.Subscript]:
-			return isinstance(node, ast.Subscript) and ifThis._nested_Identifier(identifier)(DOT.value(node))
+			return be.Subscript(node) and ifThis._nested_Identifier(identifier)(DOT.value(node))
 		return workhorse
 
 	@staticmethod

mapFolding/someAssemblyRequired/_toolboxContainers.py

@@ -29,7 +29,6 @@ from Z0Z_tools import updateExtendPolishDictionaryLists
 import ast
 import dataclasses
 
-# Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
 class LedgerOfImports:
 	"""
 	Track and manage import statements for programmatically generated code.
@@ -58,23 +57,22 @@ class LedgerOfImports:
 			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 isinstance(astImport____, ast.Import):
-			for alias in astImport____.names:
-				self.listImport.append(alias.name)
-		elif isinstance(astImport____, ast.ImportFrom): # type: ignore
-			# 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))
+		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}.")
 
 	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] = []
@@ -85,15 +83,14 @@ class LedgerOfImports:
 		self.removeImportFrom(moduleWithLogicalPath, None, None)
 
 	def removeImportFrom(self, moduleWithLogicalPath: str_nameDOTname, name: ast_Identifier | None, asname: ast_Identifier | None = None) -> None:
-		assert moduleWithLogicalPath is not None, SyntaxError(f"I received `{moduleWithLogicalPath = }`, but it must be the name of a module.")
+		"""
+		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:
-			"""
-			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)
@@ -102,7 +99,6 @@ class LedgerOfImports:
 					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]:
@@ -255,7 +251,6 @@ class IngredientsModule:
 	def appendIngredientsFunction(self, *ingredientsFunction: IngredientsFunction) -> None:
 		"""Append one or more `IngredientsFunction`."""
 		for allegedIngredientsFunction in ingredientsFunction:
-			assert isinstance(allegedIngredientsFunction, IngredientsFunction), ValueError(f"I received `{type(allegedIngredientsFunction) = }`, but I can only accept `{IngredientsFunction}`.")
 			self.listIngredientsFunctions.append(allegedIngredientsFunction)
 
 	def removeImportFromModule(self, moduleWithLogicalPath: str_nameDOTname) -> None:
@@ -308,7 +303,7 @@ class IngredientsModule:
 @dataclasses.dataclass
 class RecipeSynthesizeFlow:
 	"""
-	Configure the generation of optimized Numba-accelerated code modules.
+	Configure the generation of new modules, including Numba-accelerated code modules.
 
 	RecipeSynthesizeFlow defines the complete blueprint for transforming an original
 	Python algorithm into an optimized, accelerated implementation. It specifies:
@@ -358,7 +353,7 @@ class RecipeSynthesizeFlow:
 	""" `logicalPathFlowRoot` likely corresponds to a physical filesystem directory."""
 
 	# Module ================================
-	moduleDispatcher: ast_Identifier = 'numbaCount_doTheNeedful'
+	moduleDispatcher: ast_Identifier = 'numbaCount'
 	moduleInitialize: ast_Identifier = moduleDispatcher
 	moduleParallel: ast_Identifier = moduleDispatcher
 	moduleSequential: ast_Identifier = moduleDispatcher
@@ -376,6 +371,10 @@ class RecipeSynthesizeFlow:
 	dataclassInstance: ast_Identifier = sourceDataclassInstance
 	dataclassInstanceTaskDistribution: ast_Identifier = sourceDataclassInstanceTaskDistribution
 
+	removeDataclassDispatcher: bool = False
+	removeDataclassInitialize: bool = False
+	removeDataclassParallel: bool = True
+	removeDataclassSequential: bool = True
 	# ========================================
 	# Computed
 	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
@@ -432,10 +431,10 @@ class ShatteredDataclass:
 	countingVariableName: ast.Name
 	"""AST name node representing the counting variable identifier."""
 
-	field2AnnAssign: dict[ast_Identifier, ast.AnnAssign] = dataclasses.field(default_factory=dict)
+	field2AnnAssign: dict[ast_Identifier, ast.AnnAssign | ast.Assign] = 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)
+	Z0Z_field2AnnAssign: dict[ast_Identifier, tuple[ast.AnnAssign | ast.Assign, str]] = dataclasses.field(default_factory=dict)
 
 	fragments4AssignmentOrParameters: ast.Tuple = dummyTuple
 	"""AST tuple used as target for assignment to capture returned fragments."""

mapFolding/someAssemblyRequired/_toolboxPython.py

@@ -107,6 +107,7 @@ def importPathFilename2Callable(pathFilename: PathLike[Any] | PurePath, identifi
 	Load a callable (function, class, etc.) from a Python file.
 	This function imports a specified Python file as a module, extracts a callable object
 	from it by name, and returns that callable.
+
 	Parameters
 	----------
 	pathFilename : Union[PathLike[Any], PurePath]
@@ -115,10 +116,12 @@ def importPathFilename2Callable(pathFilename: PathLike[Any] | PurePath, identifi
 		Name of the callable to extract from the imported module.
 	moduleIdentifier : Optional[str]
 		Name to use for the imported module. If None, the filename stem is used.
+
 	Returns
 	-------
 	Callable[..., Any]
 		The callable object extracted from the imported module.
+
 	Raises
 	------
 	ImportError

mapFolding/someAssemblyRequired/synthesizeNumbaJob.py

@@ -18,16 +18,26 @@ This creates extremely fast, specialized implementations that can be run directl
 as Python scripts or further compiled into standalone executables.
 """
 
-from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal
-from mapFolding.someAssemblyRequired import ast_Identifier, ifThis, Make, NodeChanger, Then, IngredientsFunction, IngredientsModule, LedgerOfImports
-from mapFolding.someAssemblyRequired.toolboxNumba import RecipeJob, SpicesJobNumba, decorateCallableWithNumba
-from mapFolding.someAssemblyRequired.transformationTools import 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 mapFolding import getPathFilenameFoldsTotal, raiseIfNoneGitHubIssueNumber3, The
+from mapFolding.someAssemblyRequired import (
+	ast_Identifier,
+	be,
+	ifThis,
+	IngredientsFunction,
+	IngredientsModule,
+	LedgerOfImports,
+	Make,
+	NodeChanger,
+	NodeTourist,
+	str_nameDOTname,
+	Then,
+)
+from mapFolding.someAssemblyRequired.RecipeJob import RecipeJob
+from mapFolding.someAssemblyRequired.toolboxNumba import parametersNumbaLight, SpicesJobNumba, decorateCallableWithNumba
+from mapFolding.someAssemblyRequired.transformationTools import dictionaryEstimates, extractFunctionDef, write_astModule, makeInitializedComputationState
 from pathlib import PurePosixPath
+from typing import cast, NamedTuple
+from Z0Z_tools import autoDecodingRLE
 import ast
 """Synthesize one file to compute `foldsTotal` of `mapShape`."""
 
@@ -89,6 +99,10 @@ if __name__ == '__main__':
 	countWithProgressBar = NodeChanger(findThis, doThat)
 	countWithProgressBar.visit(ingredientsFunction.astFunctionDef)
 
+	removeReturnStatement = NodeChanger(be.Return, Then.removeIt)
+	removeReturnStatement.visit(ingredientsFunction.astFunctionDef)
+	ingredientsFunction.astFunctionDef.returns = Make.Constant(value=None)
+
 	ingredientsModule.appendLauncher(ast.parse(linesLaunch))
 
 	return ingredientsModule, ingredientsFunction
@@ -119,9 +133,13 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 	"""
 	ingredientsFunction.imports.update(job.shatteredDataclass.ledger)
 
-	list_IdentifiersNotUsed = list_IdentifiersNotUsedHARDCODED
-
 	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)
+	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 ast_arg in list_argCuzMyBrainRefusesToThink:
 		if ast_arg.arg in job.shatteredDataclass.field2AnnAssign:
 			if ast_arg.arg in list_IdentifiersNotUsed:
@@ -132,7 +150,7 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 					case 'scalar':
 						ImaAnnAssign.value.args[0].value = int(job.state.__dict__[ast_arg.arg]) # type: ignore
 					case 'array':
-						dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[ast_arg.arg], addSpaces=True)
+						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
 					case _:
@@ -181,11 +199,6 @@ def makeJobNumba(job: RecipeJob, spices: SpicesJobNumba) -> None:
 	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(lambda node: isinstance(node, ast.Return), Then.removeIt) # type: ignore
-	removeReturnStatement.visit(ingredientsCount.astFunctionDef)
-	ingredientsCount.astFunctionDef.returns = Make.Constant(value=None)
-
 	# Remove `foldGroups` and any other unused statements, so you can dynamically determine which variables are not used
 	findThis = ifThis.isAssignAndTargets0Is(ifThis.isSubscript_Identifier('foldGroups'))
 	doThat = Then.removeIt
@@ -199,46 +212,63 @@ def makeJobNumba(job: RecipeJob, spices: SpicesJobNumba) -> None:
 		doThat = Then.replaceWith(Make.Constant(int(job.state.__dict__[identifier])))
 		NodeChanger(findThis, doThat).visit(ingredientsCount.astFunctionDef)
 
-	# This launcher eliminates the use of one identifier, so run it now and you can dynamically determine which variables are not used
 	ingredientsModule = IngredientsModule()
+	# This launcher eliminates the use of one identifier, so run it now and you can dynamically determine which variables are not used
 	if spices.useNumbaProgressBar:
 		ingredientsModule, ingredientsCount = addLauncherNumbaProgress(ingredientsModule, ingredientsCount, job, spices)
 		spices.parametersNumba['nogil'] = True
+	else:
+		linesLaunch: str = f"""
+if __name__ == '__main__':
+	import time
+	timeStart = time.perf_counter()
+	foldsTotal = {job.countCallable}() * {job.state.leavesTotal}
+	print(time.perf_counter() - timeStart)
+	print('\\nmap {job.state.mapShape} =', foldsTotal)
+	writeStream = open('{job.pathFilenameFoldsTotal.as_posix()}', 'w')
+	writeStream.write(str(foldsTotal))
+	writeStream.close()
+"""
+	# 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.visit(ingredientsCount.astFunctionDef)
+		ingredientsCount.astFunctionDef.returns = job.shatteredDataclass.countingVariableAnnotation
 
 	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)
+	class DatatypeConfig(NamedTuple):
+		Z0Z_module: str_nameDOTname
+		fml: ast_Identifier
+		Z0Z_type_name: ast_Identifier
+		Z0Z_asname: ast_Identifier | None = None
+
+	listDatatypeConfigs = [
+		DatatypeConfig(fml='DatatypeLeavesTotal', Z0Z_module='numba', Z0Z_type_name='uint16'),
+		DatatypeConfig(fml='DatatypeElephino', Z0Z_module='numba', Z0Z_type_name='uint16'),
+		DatatypeConfig(fml='DatatypeFoldsTotal', Z0Z_module='numba', Z0Z_type_name='int64'),
+	]
+
+	for datatypeConfig in listDatatypeConfigs:
+		ingredientsModule.imports.addImportFrom_asStr(datatypeConfig.Z0Z_module, datatypeConfig.Z0Z_type_name)
+		statement = Make.Assign(
+			[Make.Name(datatypeConfig.fml, ast.Store())],
+			Make.Name(datatypeConfig.Z0Z_type_name)
+		)
+		ingredientsModule.appendPrologue(statement=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)
+
+	listNumPyTypeConfigs = [
+		DatatypeConfig(fml='Array1DLeavesTotal', Z0Z_module='numpy', Z0Z_type_name='uint16', Z0Z_asname='Array1DLeavesTotal'),
+		DatatypeConfig(fml='Array1DElephino', Z0Z_module='numpy', Z0Z_type_name='uint16', Z0Z_asname='Array1DElephino'),
+		DatatypeConfig(fml='Array3D', Z0Z_module='numpy', Z0Z_type_name='uint16', Z0Z_asname='Array3D'),
+	]
+
+	for typeConfig in listNumPyTypeConfigs:
+		ingredientsCount.imports.removeImportFrom(typeConfig.Z0Z_module, None, typeConfig.fml)
+		ingredientsCount.imports.addImportFrom_asStr(typeConfig.Z0Z_module, typeConfig.Z0Z_type_name, typeConfig.Z0Z_asname)
 
 	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:`
@@ -269,11 +299,13 @@ def makeJobNumba(job: RecipeJob, spices: SpicesJobNumba) -> None:
 	"""
 
 if __name__ == '__main__':
-	mapShape = (2,4)
+	mapShape = (2,2,2,2,2,2,2,2)
 	state = makeInitializedComputationState(mapShape)
-	foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal
+	# foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal
+	foldsTotalEstimated = dictionaryEstimates[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()
+	spices = SpicesJobNumba(useNumbaProgressBar=False, parametersNumba=parametersNumbaLight)
+	# spices = SpicesJobNumba()
 	makeJobNumba(aJob, spices)