mapFolding 0.9.3__py3-none-any.whl → 0.9.5__py3-none-any.whl

mapFolding/someAssemblyRequired/_toolboxPython.py

@@ -1,18 +1,17 @@
 """
 Core AST Traversal and Transformation Utilities for Python Code Manipulation
 
-This module provides the foundation for traversing and modifying Python Abstract
-Syntax Trees (ASTs). It contains two primary classes:
+This module provides the foundation for traversing and modifying Python Abstract Syntax Trees (ASTs). It contains two
+primary classes:
 
-1. NodeTourist: Implements the visitor pattern to traverse an AST and extract information
-   from nodes that match specific predicates without modifying the AST.
+1. NodeTourist: Implements the visitor pattern to traverse an AST and extract information from nodes that match specific
+	predicates without modifying the AST.
 
-2. NodeChanger: Extends ast.NodeTransformer to selectively transform AST nodes that
-   match specific predicates, enabling targeted code modifications.
+2. NodeChanger: Extends ast.NodeTransformer to selectively transform AST nodes that match specific predicates, enabling
+	targeted code modifications.
 
-The module also provides utilities for importing modules, loading callables from files,
-and parsing Python code into AST structures, creating a complete workflow for code
-analysis and transformation.
+The module also provides utilities for importing modules, loading callables from files, and parsing Python code into AST
+structures, creating a complete workflow for code analysis and transformation.
 """
 
 from collections.abc import Callable
@@ -32,13 +31,12 @@ class NodeTourist(ast.NodeVisitor):
 	"""
 	Visit and extract information from AST nodes that match a predicate.
 
-	NodeTourist implements the visitor pattern to traverse an AST, applying
-	a predicate function to each node and capturing nodes or their attributes
-	when they match. Unlike NodeChanger, it doesn't modify the AST but collects
+	NodeTourist implements the visitor pattern to traverse an AST, applying a predicate function to each node and
+	capturing nodes or their attributes when they match. Unlike NodeChanger, it doesn't modify the AST but collects
 	information during traversal.
 
-	This class is particularly useful for analyzing AST structures, extracting
-	specific nodes or node properties, and gathering information about code patterns.
+	This class is particularly useful for analyzing AST structures, extracting specific nodes or node properties, and
+	gathering information about code patterns.
 	"""
 	def __init__(self, findThis: Callable[..., Any], doThat: Callable[..., Any]) -> None:
 		self.findThis = findThis
@@ -61,12 +59,12 @@ class NodeChanger(ast.NodeTransformer):
 	"""
 	Transform AST nodes that match a predicate by applying a transformation function.
 
-	NodeChanger is an AST node transformer that applies a targeted transformation
-	to nodes matching a specific predicate. It traverses the AST and only modifies
-	nodes that satisfy the predicate condition, leaving other nodes unchanged.
+	NodeChanger is an AST node transformer that applies a targeted transformation to nodes matching a specific
+	predicate. It traverses the AST and only modifies nodes that satisfy the predicate condition, leaving other nodes
+	unchanged.
 
-	This class extends ast.NodeTransformer and implements the visitor pattern
-	to systematically process and transform an AST tree.
+	This class extends ast.NodeTransformer and implements the visitor pattern to systematically process and transform an
+	AST tree.
 	"""
 	def __init__(self, findThis: Callable[..., Any], doThat: Callable[..., Any]) -> None:
 		self.findThis = findThis
@@ -81,18 +79,18 @@ def importLogicalPath2Callable(logicalPathModule: str_nameDOTname, identifier: a
 	"""
 	Import a callable object (function or class) from a module based on its logical path.
 
-	This function imports a module using `importlib.import_module()` and then retrieves
-	a specific attribute (function, class, or other object) from that module.
+	This function imports a module using `importlib.import_module()` and then retrieves a specific attribute (function,
+	class, or other object) from that module.
 
 	Parameters
 	----------
-	logicalPathModule : str
+	logicalPathModule
 		The logical path to the module, using dot notation (e.g., 'package.subpackage.module').
-	identifier : str
+	identifier
 		The name of the callable object to retrieve from the module.
-	packageIdentifierIfRelative : str, optional
-		The package name to use as the anchor point if `logicalPathModule` is a relative import.
-		If None, absolute import is assumed.
+	packageIdentifierIfRelative : None
+		The package name to use as the anchor point if `logicalPathModule` is a relative import. If None, absolute
+		import is assumed.
 
 	Returns
 	-------
@@ -105,16 +103,17 @@ def importLogicalPath2Callable(logicalPathModule: str_nameDOTname, identifier: a
 def importPathFilename2Callable(pathFilename: PathLike[Any] | PurePath, identifier: ast_Identifier, moduleIdentifier: ast_Identifier | None = None) -> Callable[..., Any]:
 	"""
 	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.
+
+	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]
+	pathFilename
 		Path to the Python file to import.
-	identifier : str
+	identifier
 		Name of the callable to extract from the imported module.
-	moduleIdentifier : Optional[str]
+	moduleIdentifier
 		Name to use for the imported module. If None, the filename stem is used.
 
 	Returns
@@ -138,49 +137,52 @@ def importPathFilename2Callable(pathFilename: PathLike[Any] | PurePath, identifi
 	importlibSpecification.loader.exec_module(moduleImported_jk_hahaha)
 	return getattr(moduleImported_jk_hahaha, identifier)
 
-def parseLogicalPath2astModule(logicalPathModule: str_nameDOTname, packageIdentifierIfRelative: ast_Identifier|None=None, mode: Literal['exec'] = 'exec') -> ast.Module:
+def parseLogicalPath2astModule(logicalPathModule: str_nameDOTname, packageIdentifierIfRelative: ast_Identifier | None = None, mode: Literal['exec'] = 'exec') -> ast.Module:
 	"""
-	Parse a logical Python module path into an AST Module.
+	Parse a logical Python module path into an `ast.Module`.
 
-	This function imports a module using its logical path (e.g., 'package.subpackage.module')
-	and converts its source code into an Abstract Syntax Tree (AST) Module object.
+	This function imports a module using its logical path (e.g., 'package.subpackage.module') and converts its source
+	code into an Abstract Syntax Tree (AST) Module object.
 
 	Parameters
 	----------
-	logicalPathModule : str
+	logicalPathModule
 		The logical path to the module using dot notation (e.g., 'package.module').
-	packageIdentifierIfRelative : ast.Identifier or None, optional
+	packageIdentifierIfRelative : None
 		The package identifier to use if the module path is relative, defaults to None.
-	mode : Literal['exec'], optional
-		The parsing mode to use, defaults to 'exec'.
+	mode : Literal['exec']
+		The mode parameter for `ast.parse`. Default is `Literal['exec']`. Options are `Literal['exec']`, `"exec"` (which
+		is _not_ the same as `Literal['exec']`), `Literal['eval']`, `Literal['func_type']`, `Literal['single']`. See
+		`ast.parse` documentation for some details and much confusion.
 
 	Returns
 	-------
-	ast.Module
+	astModule
 		An AST Module object representing the parsed source code of the imported module.
 	"""
 	moduleImported: ModuleType = importlib.import_module(logicalPathModule, packageIdentifierIfRelative)
 	sourcePython: str = inspect_getsource(moduleImported)
-	return ast.parse(sourcePython, mode=mode)
+	return ast.parse(sourcePython, mode)
 
 def parsePathFilename2astModule(pathFilename: PathLike[Any] | PurePath, mode: Literal['exec'] = 'exec') -> ast.Module:
 	"""
-	Parse a file from a given path into an ast.Module.
+	Parse a file from a given path into an `ast.Module`.
 
-	This function reads the content of a file specified by `pathFilename` and parses it into an
-	Abstract Syntax Tree (AST) Module using Python's ast module.
+	This function reads the content of a file specified by `pathFilename` and parses it into an Abstract Syntax Tree
+	(AST) Module using Python's ast module.
 
 	Parameters
 	----------
-	pathFilename : PathLike[Any] | PurePath
+	pathFilename
 		The path to the file to be parsed. Can be a string path, PathLike object, or PurePath object.
-	mode : Literal['exec'], optional
-		The mode parameter for ast.parse. Default is 'exec'.
-		Options are 'exec', 'eval', or 'single'. See ast.parse documentation for details.
+	mode : Literal['exec']
+		The mode parameter for `ast.parse`. Default is `Literal['exec']`. Options are `Literal['exec']`, `"exec"` (which
+		is _not_ the same as `Literal['exec']`), `Literal['eval']`, `Literal['func_type']`, `Literal['single']`. See
+		`ast.parse` documentation for some details and much confusion.
 
 	Returns
 	-------
-	ast.Module
+	astModule
 		The parsed abstract syntax tree module.
 	"""
-	return ast.parse(Path(pathFilename).read_text(), mode=mode)
+	return ast.parse(Path(pathFilename).read_text(), mode)

mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py

@@ -0,0 +1,274 @@
+from mapFolding import getPathFilenameFoldsTotal, raiseIfNoneGitHubIssueNumber3, The
+from mapFolding.someAssemblyRequired import (
+	ast_Identifier,
+	be,
+	extractFunctionDef,
+	ifThis,
+	IngredientsFunction,
+	IngredientsModule,
+	LedgerOfImports,
+	Make,
+	NodeChanger,
+	NodeTourist,
+	str_nameDOTname,
+	Then,
+)
+from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2Numba
+from mapFolding.someAssemblyRequired.toolboxNumba import parametersNumbaLight, SpicesJobNumba, decorateCallableWithNumba
+from mapFolding.someAssemblyRequired.transformationTools import dictionaryEstimates, write_astModule, makeInitializedComputationState
+from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
+from mapFolding.dataBaskets import MapFoldingState
+from pathlib import PurePosixPath
+from typing import cast, NamedTuple
+from Z0Z_tools import autoDecodingRLE
+import ast
+"""Synthesize one file to compute `foldsTotal` of `mapShape`."""
+
+list_IdentifiersNotUsedAllHARDCODED = ['concurrencyLimit', 'foldsTotal', 'mapShape',]
+list_IdentifiersNotUsedParallelSequentialHARDCODED = ['indexLeaf']
+list_IdentifiersNotUsedSequentialHARDCODED = ['foldGroups', 'taskDivisions', 'taskIndex',]
+
+list_IdentifiersReplacedHARDCODED = ['groupsOfFolds',]
+
+list_IdentifiersStaticValuesHARDCODED = ['dimensionsTotal', 'leavesTotal',]
+
+list_IdentifiersNotUsedHARDCODED = list_IdentifiersStaticValuesHARDCODED + list_IdentifiersReplacedHARDCODED + list_IdentifiersNotUsedAllHARDCODED + list_IdentifiersNotUsedParallelSequentialHARDCODED + list_IdentifiersNotUsedSequentialHARDCODED
+
+def addLauncherNumbaProgress(ingredientsModule: IngredientsModule, ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2Numba, spices: SpicesJobNumba) -> tuple[IngredientsModule, IngredientsFunction]:
+	"""
+	Add progress tracking capabilities to a Numba-optimized function.
+
+	This function modifies both the module and the function to integrate Numba-compatible
+	progress tracking for long-running calculations. It performs several key transformations:
+
+	1. Adds a progress bar parameter to the function signature
+	2. Replaces counting increments with progress bar updates
+	3. Creates a launcher section that displays and updates progress
+	4. Configures file output to save results upon completion
+
+	The progress tracking is particularly important for map folding calculations
+	which can take hours or days to complete, providing visual feedback and
+	estimated completion times.
+
+	Parameters:
+		ingredientsModule: The module where the function is defined.
+		ingredientsFunction: The function to modify with progress tracking.
+		job: Configuration specifying shape details and output paths.
+		spices: Configuration specifying progress bar details.
+
+	Returns:
+		A tuple containing the modified module and function with progress tracking.
+	"""
+	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('\\nmap {job.state.mapShape} =', foldsTotal)
+		writeStream = open('{job.pathFilenameFoldsTotal.as_posix()}', 'w')
+		writeStream.write(str(foldsTotal))
+		writeStream.close()
+"""
+	numba_progressPythonClass: ast_Identifier = 'ProgressBar'
+	numba_progressNumbaType: ast_Identifier = 'ProgressBarType'
+	ingredientsModule.imports.addImportFrom_asStr('numba_progress', numba_progressPythonClass)
+	ingredientsModule.imports.addImportFrom_asStr('numba_progress', numba_progressNumbaType)
+
+	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(spices.numbaProgressBarIdentifier),'update'),[Make.Constant(1)])))
+	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
+
+def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2Numba) -> IngredientsFunction:
+	"""
+	Convert function parameters into initialized variables with concrete values.
+
+	This function implements a critical transformation that converts function parameters
+	into statically initialized variables in the function body. This enables several
+	optimizations:
+
+	1. Eliminating parameter passing overhead.
+	2. Embedding concrete values directly in the code.
+	3. Allowing Numba to optimize based on known value characteristics.
+	4. Simplifying function signatures for specialized use cases.
+
+	The function handles different data types (scalars, arrays, custom types) appropriately,
+	replacing abstract parameter references with concrete values from the computation state.
+	It also removes unused parameters and variables to eliminate dead code.
+
+	Parameters:
+		ingredientsFunction: The function to transform.
+		job: Recipe containing concrete values for parameters and field metadata.
+
+	Returns:
+		The modified function with parameters converted to initialized variables.
+	"""
+	ingredientsFunction.imports.update(job.shatteredDataclass.imports)
+
+	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:
+				pass
+			else:
+				ImaAnnAssign, elementConstructor = job.shatteredDataclass.Z0Z_field2AnnAssign[ast_arg.arg]
+				match elementConstructor:
+					case 'scalar':
+						ImaAnnAssign.value.args[0].value = int(job.state.__dict__[ast_arg.arg]) # type: ignore
+					case 'array':
+						dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[ast_arg.arg], True)
+						dataAs_astExpr: ast.expr = cast(ast.Expr, ast.parse(dataAsStrRLE).body[0]).value
+						ImaAnnAssign.value.args = [dataAs_astExpr] # type: ignore
+					case _:
+						list_exprDOTannotation: list[ast.expr] = []
+						list_exprDOTvalue: list[ast.expr] = []
+						for dimension in job.state.mapShape:
+							list_exprDOTannotation.append(Make.Name(elementConstructor))
+							list_exprDOTvalue.append(Make.Call(Make.Name(elementConstructor), [Make.Constant(dimension)]))
+						ImaAnnAssign.annotation.slice.elts = list_exprDOTannotation # type: ignore
+						ImaAnnAssign.value.elts = list_exprDOTvalue # type: ignore
+
+				ingredientsFunction.astFunctionDef.body.insert(0, ImaAnnAssign)
+
+			findThis = ifThis.is_arg_Identifier(ast_arg.arg)
+			remove_arg = NodeChanger(findThis, Then.removeIt)
+			remove_arg.visit(ingredientsFunction.astFunctionDef)
+
+	ast.fix_missing_locations(ingredientsFunction.astFunctionDef)
+	return ingredientsFunction
+
+def makeJobNumba(job: RecipeJobTheorem2Numba, spices: SpicesJobNumba) -> None:
+
+	astFunctionDef = extractFunctionDef(job.source_astModule, job.countCallable)
+	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
+	ingredientsCount: IngredientsFunction = IngredientsFunction(astFunctionDef, LedgerOfImports())
+
+	# Remove `foldGroups` and any other unused statements, so you can dynamically determine which variables are not used
+	findThis = ifThis.isAssignAndTargets0Is(ifThis.isSubscript_Identifier('foldGroups'))
+	doThat = Then.removeIt
+	remove_foldGroups = NodeChanger(findThis, doThat)
+	remove_foldGroups.visit(ingredientsCount.astFunctionDef)
+
+	# replace identifiers with static values with their values, so you can dynamically determine which variables are not used
+	list_IdentifiersStaticValues = list_IdentifiersStaticValuesHARDCODED
+	for identifier in list_IdentifiersStaticValues:
+		findThis = ifThis.isName_Identifier(identifier)
+		doThat = Then.replaceWith(Make.Constant(int(job.state.__dict__[identifier])))
+		NodeChanger(findThis, doThat).visit(ingredientsCount.astFunctionDef)
+
+	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)
+
+	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='uint8'),
+		DatatypeConfig(fml='DatatypeElephino', Z0Z_module='numba', Z0Z_type_name='uint16'),
+		DatatypeConfig(fml='DatatypeFoldsTotal', Z0Z_module='numba', Z0Z_type_name='uint64'),
+	]
+
+	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')
+
+	listNumPyTypeConfigs = [
+		DatatypeConfig(fml='Array1DLeavesTotal', Z0Z_module='numpy', Z0Z_type_name='uint8', 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='uint8', 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:`
+	ingredientsCount = decorateCallableWithNumba(ingredientsCount, spices.parametersNumba)
+
+	ingredientsModule.appendIngredientsFunction(ingredientsCount)
+	write_astModule(ingredientsModule, job.pathFilenameModule, job.packageIdentifier)
+
+	"""
+	Overview
+	- the code starts life in theDao.py, which has many optimizations;
+		- `makeNumbaOptimizedFlow` increase optimization especially by using numba;
+		- `makeJobNumba` increases optimization especially by limiting its capabilities to just one set of parameters
+	- the synthesized module must run well as a standalone interpreted-Python script
+	- the next major optimization step will (probably) be to use the module synthesized by `makeJobNumba` to compile a standalone executable
+	- Nevertheless, at each major optimization step, the code is constantly being improved and optimized, so everything must be well organized (read: semantic) and able to handle a range of arbitrary upstream and not disrupt downstream transformations
+
+	Necessary
+	- Move the function's parameters to the function body,
+	- initialize identifiers with their state types and values,
+
+	Optimizations
+	- replace static-valued identifiers with their values
+	- narrowly focused imports
+
+	Minutia
+	- do not use `with` statement inside numba jitted code, except to use numba's obj mode
+	"""
+
+if __name__ == '__main__':
+	mapShape = (1,46)
+	state = MapFoldingState(mapShape)
+	state = initializeGroupsOfFolds(state)
+	# foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal
+	# foldsTotalEstimated = dictionaryEstimates[state.mapShape] // state.leavesTotal
+	foldsTotalEstimated = 0
+	pathModule = PurePosixPath(The.pathPackage, 'jobs')
+	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
+	aJob = RecipeJobTheorem2Numba(state, foldsTotalEstimated, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
+	spices = SpicesJobNumba(useNumbaProgressBar=False, parametersNumba=parametersNumbaLight)
+	# spices = SpicesJobNumba()
+	makeJobNumba(aJob, spices)

mapFolding/someAssemblyRequired/synthesizeNumbaJob.py

@@ -22,6 +22,7 @@ from mapFolding import getPathFilenameFoldsTotal, raiseIfNoneGitHubIssueNumber3,
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
 	be,
+	extractFunctionDef,
 	ifThis,
 	IngredientsFunction,
 	IngredientsModule,
@@ -34,7 +35,7 @@ from mapFolding.someAssemblyRequired import (
 )
 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 mapFolding.someAssemblyRequired.transformationTools import dictionaryEstimates, write_astModule, makeInitializedComputationState
 from pathlib import PurePosixPath
 from typing import cast, NamedTuple
 from Z0Z_tools import autoDecodingRLE
@@ -131,7 +132,7 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 	Returns:
 		The modified function with parameters converted to initialized variables.
 	"""
-	ingredientsFunction.imports.update(job.shatteredDataclass.ledger)
+	ingredientsFunction.imports.update(job.shatteredDataclass.imports)
 
 	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]
@@ -299,10 +300,11 @@ if __name__ == '__main__':
 	"""
 
 if __name__ == '__main__':
-	mapShape = (2,21)
+	mapShape = (1,46)
 	state = makeInitializedComputationState(mapShape)
 	# foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal
-	foldsTotalEstimated = dictionaryEstimates[state.mapShape] // state.leavesTotal
+	# foldsTotalEstimated = dictionaryEstimates[state.mapShape] // state.leavesTotal
+	foldsTotalEstimated = 0
 	pathModule = PurePosixPath(The.pathPackage, 'jobs')
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
 	aJob = RecipeJob(state, foldsTotalEstimated, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)

mapFolding/someAssemblyRequired/toolboxNumba.py

@@ -16,23 +16,14 @@ performance improvements while preserving code semantics and correctness.
 """
 
 from collections.abc import Callable, Sequence
-from mapFolding.someAssemblyRequired import ast_Identifier, be, IngredientsFunction, Make, NodeTourist, RecipeSynthesizeFlow, str_nameDOTname, Then
+from mapFolding import NotRequired, TypedDict
+from mapFolding.someAssemblyRequired import ast_Identifier, IngredientsFunction, Make, RecipeSynthesizeFlow, str_nameDOTname
 from mapFolding.someAssemblyRequired.transformationTools import makeNewFlow, write_astModule
 from numba.core.compiler import CompilerBase as numbaCompilerBase
-from typing import Any, cast, Final, TYPE_CHECKING, TypeGuard
+from typing import Any, cast, Final
 import ast
 import dataclasses
 
-try:
-	from typing import NotRequired
-except Exception:
-	from typing_extensions import NotRequired # pyright: ignore[reportShadowedImports]
-
-if TYPE_CHECKING:
-	from typing import TypedDict
-else:
-	TypedDict = dict[str,Any]
-
 # Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
 theNumbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()
 
@@ -60,17 +51,8 @@ class ParametersNumba(TypedDict):
 	signature_or_function: NotRequired[Any | Callable[..., Any] | str | tuple[Any, ...]]
 	target: NotRequired[str]
 
-parametersNumbaFailEarly: Final[ParametersNumba] = { '_nrt': True, 'boundscheck': True, 'cache': True, 'error_model': 'python', 'fastmath': False, 'forceinline': True, 'inline': 'always', 'looplift': False, 'no_cfunc_wrapper': False, 'no_cpython_wrapper': False, 'nopython': True, 'parallel': False, }
-"""For a production function: speed is irrelevant, error discovery is paramount, must be compatible with anything downstream."""
 parametersNumbaDefault: Final[ParametersNumba] = { '_nrt': True, 'boundscheck': False, 'cache': True, 'error_model': 'numpy', 'fastmath': True, 'forceinline': True, 'inline': 'always', 'looplift': False, 'no_cfunc_wrapper': False, 'no_cpython_wrapper': False, 'nopython': True, 'parallel': False, }
 """Middle of the road: fast, lean, but will talk to non-jitted functions."""
-parametersNumbaParallelDEFAULT: Final[ParametersNumba] = { **parametersNumbaDefault, '_nrt': True, 'parallel': True, }
-"""Middle of the road: fast, lean, but will talk to non-jitted functions."""
-parametersNumbaSuperJit: Final[ParametersNumba] = { **parametersNumbaDefault, 'no_cfunc_wrapper': True, 'no_cpython_wrapper': True, }
-"""Speed, no helmet, no talking to non-jitted functions."""
-parametersNumbaSuperJitParallel: Final[ParametersNumba] = { **parametersNumbaSuperJit, '_nrt': True, 'parallel': True, }
-"""Speed, no helmet, concurrency, no talking to non-jitted functions."""
-parametersNumbaMinimum: Final[ParametersNumba] = { '_nrt': True, 'boundscheck': True, 'cache': True, 'error_model': 'numpy', 'fastmath': True, 'forceinline': False, 'inline': 'always', 'looplift': False, 'no_cfunc_wrapper': False, 'no_cpython_wrapper': False, 'nopython': False, 'forceobj': True, 'parallel': False, }
 parametersNumbaLight: Final[ParametersNumba] = {'cache': True, 'error_model': 'numpy', 'fastmath': True, 'forceinline': True}
 
 Z0Z_numbaDataTypeModule: str_nameDOTname = 'numba'
@@ -188,11 +170,5 @@ def makeNumbaFlow(numbaFlow: RecipeSynthesizeFlow) -> None:
 
 	write_astModule(ingredientsModuleNumbaUnified, numbaFlow.pathFilenameDispatcher, numbaFlow.packageIdentifier)
 
-def getIt(astCallConcurrencyResult: list[ast.Call]) -> Callable[[ast.AST], ast.AST]:
-	def workhorse(node: ast.AST) -> ast.AST:
-		NodeTourist(be.Call, Then.appendTo(astCallConcurrencyResult)).visit(node)
-		return node
-	return workhorse
-
 if __name__ == '__main__':
 	makeNumbaFlow(theNumbaFlow)