mapFolding 0.9.0__tar.gz → 0.9.1__tar.gz

{mapfolding-0.9.0 → mapfolding-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.9.0
+Version: 0.9.1
 Summary: Map folding algorithm with code transformation framework for optimizing numerical computations
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0

{mapfolding-0.9.0 → mapfolding-0.9.1}/mapFolding/beDRY.py

@@ -331,8 +331,7 @@ def validateListDimensions(listDimensions: Sequence[int]) -> tuple[int, ...]:
 	ValueError
 		If the input is empty or contains negative values.
 	NotImplementedError
-		If fewer than two positive dimensions are provided, as this would not
-		represent a valid map folding problem.
+		If fewer than two positive dimensions are provided.
 	"""
 	if not listDimensions:
 		raise ValueError("`listDimensions` is a required parameter.")

{mapfolding-0.9.0 → mapfolding-0.9.1}/mapFolding/oeis.py

@@ -59,14 +59,20 @@ class SettingsOEIShardcodedValues(TypedDict):
 	valuesTestValidation: list[int]
 
 settingsOEIShardcodedValues: dict[str, SettingsOEIShardcodedValues] = {
+	'A000136': {
+		'getMapShape': lambda n: tuple(sorted([1, n])),
+		'valuesBenchmark': [14],
+		'valuesTestParallelization': [*range(3, 7)],
+		'valuesTestValidation': [random.randint(2, 9)],
+	},
 	'A001415': {
-		'getMapShape': lambda n: (2, n) if n >= 2 else (n, 2),
+		'getMapShape': lambda n: tuple(sorted([2, n])),
 		'valuesBenchmark': [14],
 		'valuesTestParallelization': [*range(3, 7)],
 		'valuesTestValidation': [random.randint(2, 9)],
 	},
 	'A001416': {
-		'getMapShape': lambda n: (3, n) if n >= 3 else (n, 3),
+		'getMapShape': lambda n: tuple(sorted([3, n])),
 		'valuesBenchmark': [9],
 		'valuesTestParallelization': [*range(3, 5)],
 		'valuesTestValidation': [random.randint(2, 6)],
@@ -148,9 +154,9 @@ def _parseBFileOEIS(OEISbFile: str, oeisID: str) -> dict[int, int]:
 		sequence ID or if the content format is invalid.
 	"""
 	bFileLines: list[str] = OEISbFile.strip().splitlines()
-	if not bFileLines.pop(0).startswith(f"# {oeisID}"):
-		warnings.warn(f"Content does not match sequence {oeisID}")
-		return {-1: -1}
+	# if not bFileLines.pop(0).startswith(f"# {oeisID}"):
+	# 	warnings.warn(f"Content does not match sequence {oeisID}")
+	# 	return {-1: -1}
 
 	OEISsequence: dict[int, int] = {}
 	for line in bFileLines:
@@ -287,20 +293,20 @@ def getOEISidInformation(oeisID: str) -> tuple[str, int]:
 def makeSettingsOEIS() -> dict[str, SettingsOEIS]:
 	"""
 	Construct the comprehensive settings dictionary for all implemented OEIS sequences.
-	
-	This function builds a complete configuration dictionary for all supported OEIS 
+
+	This function builds a complete configuration dictionary for all supported OEIS
 	sequences by retrieving and combining:
 	1. Sequence values from OEIS b-files
 	2. Sequence metadata (descriptions and offsets)
 	3. Hardcoded mapping functions and test values
-	
-	The resulting dictionary provides a single authoritative source for all OEIS-related 
+
+	The resulting dictionary provides a single authoritative source for all OEIS-related
 	configurations used throughout the package, including:
 	- Mathematical descriptions of each sequence
 	- Functions to convert between sequence indices and map dimensions
 	- Known sequence values retrieved from OEIS
 	- Testing and benchmarking reference values
-	
+
 	Returns:
 		A dictionary mapping OEIS sequence IDs to their complete settings objects,
 		containing all metadata and known values needed for computation and validation.
@@ -341,18 +347,18 @@ def makeDictionaryFoldsTotalKnown() -> dict[tuple[int, ...], int]:
 def getFoldsTotalKnown(mapShape: tuple[int, ...]) -> int:
 	"""
 	Retrieve the known total number of foldings for a given map shape.
-	
+
 	This function looks up precalculated folding totals for specific map dimensions
 	from OEIS sequences. It serves as a rapid reference for known values without
 	requiring computation, and can be used to validate algorithm results.
-	
+
 	Parameters:
 		mapShape: A tuple of integers representing the dimensions of the map.
-	
+
 	Returns:
 		foldingsTotal: The known total number of foldings for the given map shape,
 		or -1 if the map shape doesn't match any known values in the OEIS sequences.
-	
+
 	Notes:
 		The function uses a cached dictionary (via makeDictionaryFoldsTotalKnown) to
 		efficiently retrieve values without repeatedly parsing OEIS data. Map shape

mapfolding-0.9.1/mapFolding/someAssemblyRequired/RecipeJob.py

@@ -0,0 +1,103 @@
+from mapFolding.someAssemblyRequired import ShatteredDataclass, ast_Identifier, parsePathFilename2astModule, str_nameDOTname
+from mapFolding.someAssemblyRequired.toolboxNumba import theNumbaFlow
+from mapFolding.someAssemblyRequired.transformationTools import shatter_dataclassesDOTdataclass
+from mapFolding.theSSOT import ComputationState, DatatypeElephino as TheDatatypeElephino, DatatypeFoldsTotal as TheDatatypeFoldsTotal, DatatypeLeavesTotal as TheDatatypeLeavesTotal
+from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal, getPathRootJobDEFAULT
+
+import dataclasses
+from pathlib import Path, PurePosixPath
+from typing import TypeAlias
+
+@dataclasses.dataclass
+class RecipeJob:
+	state: ComputationState
+	# TODO create function to calculate `foldsTotalEstimated`
+	foldsTotalEstimated: int = 0
+	shatteredDataclass: ShatteredDataclass = dataclasses.field(default=None, init=True) # pyright: ignore[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) # pyright: ignore[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) # pyright: ignore[reportAssignmentType]
+	countCallable: ast_Identifier = sourceCountCallable
+	dataclassIdentifier: ast_Identifier | None = sourceDataclassIdentifier
+	dataclassInstance: ast_Identifier | None = sourceDataclassInstance
+	logicalPathModuleDataclass: str_nameDOTname | None = sourceLogicalPathModuleDataclass
+
+	# ========================================
+	# Datatypes
+	DatatypeFoldsTotal: TypeAlias = TheDatatypeFoldsTotal
+	DatatypeElephino: TypeAlias = TheDatatypeElephino
+	DatatypeLeavesTotal: TypeAlias = TheDatatypeLeavesTotal
+
+	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: # pyright: ignore[reportUnnecessaryComparison]
+			self.moduleIdentifier = pathFilenameFoldsTotal.stem
+
+		if self.pathFilenameFoldsTotal is None: # pyright: ignore[reportUnnecessaryComparison]
+			self.pathFilenameFoldsTotal = pathFilenameFoldsTotal
+
+		if self.shatteredDataclass is None and self.logicalPathModuleDataclass and self.dataclassIdentifier and self.dataclassInstance: # pyright: ignore[reportUnnecessaryComparison]
+			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

{mapfolding-0.9.0 → mapfolding-0.9.1}/mapFolding/someAssemblyRequired/__init__.py

@@ -48,40 +48,40 @@ to verify correctness at each transformation stage through the integrated test s
 """
 
 from mapFolding.someAssemblyRequired._theTypes import (
-	ast_expr_Slice,
-	ast_Identifier,
-	astClassHasDOTnameNotName,
-	astClassHasDOTtarget,
-	astClassHasDOTvalue_expr,
-	astClassHasDOTvalue_exprNone,
-	astClassHasDOTtargetAttributeNameSubscript,
-	astClassHasDOTtarget_expr,
-	astClassHasDOTvalue,
-	astClassOptionallyHasDOTnameNotName,
-	intORlist_ast_type_paramORstr_orNone,
-	intORstr_orNone,
-	list_ast_type_paramORstr_orNone,
-	str_nameDOTname,
-	个,
+	ast_expr_Slice as ast_expr_Slice,
+	ast_Identifier as ast_Identifier,
+	astClassHasDOTnameNotName as astClassHasDOTnameNotName,
+	astClassHasDOTtarget as astClassHasDOTtarget,
+	astClassHasDOTvalue_expr as astClassHasDOTvalue_expr,
+	astClassHasDOTvalue_exprNone as astClassHasDOTvalue_exprNone,
+	astClassHasDOTtargetAttributeNameSubscript as astClassHasDOTtargetAttributeNameSubscript,
+	astClassHasDOTtarget_expr as astClassHasDOTtarget_expr,
+	astClassHasDOTvalue as astClassHasDOTvalue,
+	astClassOptionallyHasDOTnameNotName as astClassOptionallyHasDOTnameNotName,
+	intORlist_ast_type_paramORstr_orNone as intORlist_ast_type_paramORstr_orNone,
+	intORstr_orNone as intORstr_orNone,
+	list_ast_type_paramORstr_orNone as list_ast_type_paramORstr_orNone,
+	str_nameDOTname as str_nameDOTname,
+	个 as 个,
 	)
 
 from mapFolding.someAssemblyRequired._toolboxPython import (
-	importLogicalPath2Callable,
-	importPathFilename2Callable,
-	NodeChanger,
-	NodeTourist,
-	parseLogicalPath2astModule,
-	parsePathFilename2astModule,
+	importLogicalPath2Callable as importLogicalPath2Callable,
+	importPathFilename2Callable as importPathFilename2Callable,
+	NodeChanger as NodeChanger,
+	NodeTourist as NodeTourist,
+	parseLogicalPath2astModule as parseLogicalPath2astModule,
+	parsePathFilename2astModule as parsePathFilename2astModule,
 	)
 
-from mapFolding.someAssemblyRequired._toolboxAntecedents import DOT, ifThis
-from mapFolding.someAssemblyRequired._tool_Make import Make
-from mapFolding.someAssemblyRequired._tool_Then import grab, Then
+from mapFolding.someAssemblyRequired._toolboxAntecedents import be as be, DOT as DOT, ifThis as ifThis
+from mapFolding.someAssemblyRequired._tool_Make import Make as Make
+from mapFolding.someAssemblyRequired._tool_Then import grab as grab, Then as Then
 
 from mapFolding.someAssemblyRequired._toolboxContainers import (
-	IngredientsFunction,
-	IngredientsModule,
-	LedgerOfImports,
-	RecipeSynthesizeFlow,
-	ShatteredDataclass,
+	IngredientsFunction as IngredientsFunction,
+	IngredientsModule as IngredientsModule,
+	LedgerOfImports as LedgerOfImports,
+	RecipeSynthesizeFlow as RecipeSynthesizeFlow,
+	ShatteredDataclass as ShatteredDataclass,
 )

{mapfolding-0.9.0 → mapfolding-0.9.1}/mapFolding/someAssemblyRequired/_tool_Make.py

@@ -56,7 +56,7 @@ class Make:
 		return ast.arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg, defaults)
 
 	@staticmethod
-	def Assign(listTargets: Any, value: ast.expr, **keywordArguments: intORstr_orNone) -> ast.Assign:
+	def Assign(listTargets: list[ast.expr], value: ast.expr, **keywordArguments: intORstr_orNone) -> ast.Assign:
 		return ast.Assign(listTargets, value, **keywordArguments)
 
 	@staticmethod

{mapfolding-0.9.0 → mapfolding-0.9.1}/mapFolding/someAssemblyRequired/_toolboxAntecedents.py

@@ -231,3 +231,15 @@ class ifThis:
 	def Z0Z_unparseIs(astAST: ast.AST) -> Callable[[ast.AST], bool]:
 		def workhorse(node: ast.AST) -> bool: return ast.unparse(node) == ast.unparse(astAST)
 		return workhorse
+
+
+class be:
+	@staticmethod
+	def Call(node: ast.AST) -> TypeGuard[ast.Call]:
+		return isinstance(node, ast.Call)
+	@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)

{mapfolding-0.9.0 → mapfolding-0.9.1}/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]:
@@ -308,7 +304,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 +354,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 +372,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 +432,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-0.9.0 → mapfolding-0.9.1}/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-0.9.0 → mapfolding-0.9.1}/mapFolding/someAssemblyRequired/synthesizeNumbaJob.py

@@ -19,12 +19,22 @@ 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 mapFolding.someAssemblyRequired import (
+	ast_Identifier,
+	be,
+	ifThis,
+	IngredientsFunction,
+	IngredientsModule,
+	LedgerOfImports,
+	Make,
+	NodeChanger,
+	NodeTourist,
+	Then,
+)
+from mapFolding.someAssemblyRequired.toolboxNumba import parametersNumbaLight, SpicesJobNumba, decorateCallableWithNumba
+from mapFolding.someAssemblyRequired.transformationTools import extractFunctionDef, write_astModule, makeInitializedComputationState
+from mapFolding.someAssemblyRequired.RecipeJob import RecipeJob
+from mapFolding import The, raiseIfNoneGitHubIssueNumber3, getFoldsTotalKnown
 from typing import cast
 from Z0Z_tools import autoDecodingRLE
 from pathlib import PurePosixPath
@@ -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:
@@ -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,30 +212,48 @@ 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))
+	Z0Z_statement = Make.Assign([Make.Name(Z0Z_Identifier, ast.Store())], Make.Name(Z0Z_type))
 	ingredientsModule.appendPrologue(statement=Z0Z_statement)
 
 	Z0Z_Identifier = 'DatatypeElephino'
-	Z0Z_type = 'int16'
+	Z0Z_type = 'uint8'
+	ingredientsModule.imports.addImportFrom_asStr('numba', Z0Z_type)
+	Z0Z_statement = Make.Assign([Make.Name(Z0Z_Identifier, ast.Store())], Make.Name(Z0Z_type))
+	ingredientsModule.appendPrologue(statement=Z0Z_statement)
+
+	Z0Z_Identifier = 'DatatypeFoldsTotal'
+	Z0Z_type = 'int64'
 	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))
+	Z0Z_statement = Make.Assign([Make.Name(Z0Z_Identifier, ast.Store())], Make.Name(Z0Z_type))
 	ingredientsModule.appendPrologue(statement=Z0Z_statement)
 
 	ingredientsCount.imports.removeImportFromModule('mapFolding.theSSOT')
@@ -233,7 +264,7 @@ def makeJobNumba(job: RecipeJob, spices: SpicesJobNumba) -> None:
 	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'
+	Z0Z_type_name = 'uint8'
 	ingredientsCount.imports.addImportFrom_asStr(Z0Z_module, Z0Z_type_name, Z0Z_asname)
 	Z0Z_asname = 'Array3D'
 	ingredientsCount.imports.removeImportFrom(Z0Z_module, None, Z0Z_asname)
@@ -269,11 +300,12 @@ def makeJobNumba(job: RecipeJob, spices: SpicesJobNumba) -> None:
 	"""
 
 if __name__ == '__main__':
-	mapShape = (2,4)
+	mapShape = (1,24)
 	state = makeInitializedComputationState(mapShape)
 	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()
+	spices = SpicesJobNumba(useNumbaProgressBar=False, parametersNumba=parametersNumbaLight)
+	# spices = SpicesJobNumba()
 	makeJobNumba(aJob, spices)