mapFolding 0.12.2__py3-none-any.whl → 0.12.3__py3-none-any.whl

mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py

@@ -29,36 +29,37 @@ essential progress feedback capabilities for large-scale computational research.
 """
 
 from astToolkit import (
-	Be, ClassIsAndAttribute, extractFunctionDef, identifierDotAttribute, IngredientsFunction,
-	IngredientsModule, LedgerOfImports, Make, NodeChanger, NodeTourist, Then,
-)
+	Be, extractFunctionDef, identifierDotAttribute, IngredientsFunction, IngredientsModule, LedgerOfImports, Make,
+	NodeChanger, NodeTourist, Then)
 from astToolkit.transformationTools import write_astModule
+from hunterMakesPy import autoDecodingRLE, raiseIfNone
 from mapFolding import getPathFilenameFoldsTotal, MapFoldingState, packageSettings
 from mapFolding.someAssemblyRequired import IfThis
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2Numba
-from mapFolding.someAssemblyRequired.toolkitNumba import (
-	decorateCallableWithNumba, parametersNumbaLight, SpicesJobNumba,
-)
+from mapFolding.someAssemblyRequired.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight, SpicesJobNumba
 from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
 from pathlib import PurePosixPath
-from typing import cast, NamedTuple
-from Z0Z_tools import autoDecodingRLE, raiseIfNone
+from typing import cast, NamedTuple, TYPE_CHECKING
+from typing_extensions import TypeIs
 import ast
 
+if TYPE_CHECKING:
+	from collections.abc import Callable
+
 # Configuration lists for code optimization and dead code elimination
-listIdentifiersNotUsedAllHARDCODED: list[str] = ['concurrencyLimit', 'foldsTotal', 'mapShape',]
+listIdentifiersNotUsedAllHARDCODED: list[str] = ['concurrencyLimit', 'foldsTotal', 'mapShape']
 """Identifiers that are universally unused across all optimization contexts."""
 
 listIdentifiersNotUsedParallelSequentialHARDCODED: list[str] = ['indexLeaf']
 """Identifiers unused in both parallel and sequential execution modes."""
 
-listIdentifiersNotUsedSequentialHARDCODED: list[str] = ['foldGroups', 'taskDivisions', 'taskIndex',]
+listIdentifiersNotUsedSequentialHARDCODED: list[str] = ['foldGroups', 'taskDivisions', 'taskIndex']
 """Identifiers unused specifically in sequential execution mode."""
 
-listIdentifiersReplacedHARDCODED: list[str] = ['groupsOfFolds',]
+listIdentifiersReplacedHARDCODED: list[str] = ['groupsOfFolds']
 """Identifiers that get replaced with optimized equivalents during transformation."""
 
-listIdentifiersStaticValuesHARDCODED: list[str] = ['dimensionsTotal', 'leavesTotal',]
+listIdentifiersStaticValuesHARDCODED: list[str] = ['dimensionsTotal', 'leavesTotal']
 """Identifiers with compile-time constant values that can be embedded directly."""
 
 listIdentifiersNotUsedHARDCODED: list[str] = listIdentifiersStaticValuesHARDCODED + listIdentifiersReplacedHARDCODED + listIdentifiersNotUsedAllHARDCODED + listIdentifiersNotUsedParallelSequentialHARDCODED + listIdentifiersNotUsedSequentialHARDCODED
@@ -67,6 +68,8 @@ listIdentifiersNotUsedHARDCODED: list[str] = listIdentifiersStaticValuesHARDCODE
 def addLauncherNumbaProgress(ingredientsModule: IngredientsModule, ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2Numba, spices: SpicesJobNumba) -> tuple[IngredientsModule, IngredientsFunction]:
 	"""Add progress tracking capabilities to a Numba-optimized function.
 
+	(AI generated docstring)
+
 	This function modifies both the module and the function to integrate Numba-compatible
 	progress tracking for long-running calculations. It performs several key transformations:
 
@@ -79,16 +82,23 @@ def addLauncherNumbaProgress(ingredientsModule: IngredientsModule, ingredientsFu
 	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:
+	Parameters
+	----------
+	ingredientsModule : IngredientsModule
+		The module where the function is defined.
+	ingredientsFunction : IngredientsFunction
+		The function to modify with progress tracking.
+	job : RecipeJobTheorem2Numba
+		Configuration specifying shape details and output paths.
+	spices : SpicesJobNumba
+		Configuration specifying progress bar details.
+
+	Returns
+	-------
+	moduleAndFunction : tuple[IngredientsModule, IngredientsFunction]
 		Modified module and function with integrated progress tracking capabilities.
-	"""
 
+	"""
 	linesLaunch: str = f"""
 if __name__ == '__main__':
 	with ProgressBar(total={job.foldsTotalEstimated}, update_interval=2) as statusUpdate:
@@ -107,9 +117,9 @@ if __name__ == '__main__':
 	ast_argNumbaProgress = ast.arg(arg=spices.numbaProgressBarIdentifier, annotation=ast.Name(id=numba_progressPythonClass, ctx=ast.Load()))
 	ingredientsFunction.astFunctionDef.args.args.append(ast_argNumbaProgress)
 
-	findThis = ClassIsAndAttribute.targetIs(ast.AugAssign, IfThis.isNameIdentifier(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)
+	findThis: Callable[[ast.AST], TypeIs[ast.AugAssign] | bool] = Be.AugAssign.targetIs(IfThis.isNameIdentifier(job.shatteredDataclass.countingVariableName.id))
+	doThat: Callable[[ast.AugAssign], ast.Expr] = Then.replaceWith(Make.Expr(Make.Call(Make.Attribute(Make.Name(spices.numbaProgressBarIdentifier),'update'),[Make.Constant(1)])))
+	countWithProgressBar: NodeChanger[ast.AugAssign, ast.Expr] = NodeChanger(findThis, doThat)
 	countWithProgressBar.visit(ingredientsFunction.astFunctionDef)
 
 	removeReturnStatement = NodeChanger(Be.Return, Then.removeIt)
@@ -123,6 +133,8 @@ if __name__ == '__main__':
 def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2Numba) -> IngredientsFunction:
 	"""Convert function parameters into initialized variables with concrete values.
 
+	(AI generated docstring)
+
 	This function implements a critical transformation that converts function parameters
 	into statically initialized variables in the function body. This enables several
 	optimizations:
@@ -136,12 +148,18 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 	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.
+	Parameters
+	----------
+	ingredientsFunction : IngredientsFunction
+		The function to transform.
+	job : RecipeJobTheorem2Numba
+		Recipe containing concrete values for parameters and field metadata.
 
-	Returns:
+	Returns
+	-------
+	modifiedFunction : IngredientsFunction
 		The modified function with parameters converted to initialized variables.
+
 	"""
 	ingredientsFunction.imports.update(job.shatteredDataclass.imports)
 
@@ -160,24 +178,24 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 				ImaAnnAssign, elementConstructor = job.shatteredDataclass.Z0Z_field2AnnAssign[ast_arg.arg]
 				match elementConstructor:
 					case 'scalar':
-						cast(ast.Constant, cast(ast.Call, ImaAnnAssign.value).args[0]).value = int(job.state.__dict__[ast_arg.arg])
+						cast('ast.Constant', cast('ast.Call', ImaAnnAssign.value).args[0]).value = int(job.state.__dict__[ast_arg.arg])
 					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
-						cast(ast.Call, ImaAnnAssign.value).args = [dataAs_astExpr]
+						dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[ast_arg.arg], assumeAddSpaces=True)
+						dataAs_astExpr: ast.expr = cast('ast.Expr', ast.parse(dataAsStrRLE).body[0]).value
+						cast('ast.Call', ImaAnnAssign.value).args = [dataAs_astExpr]
 					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)]))
-						cast(ast.Tuple, cast(ast.Subscript, cast(ast.AnnAssign, ImaAnnAssign).annotation).slice).elts = list_exprDOTannotation
-						cast(ast.Tuple, ImaAnnAssign.value).elts = list_exprDOTvalue
+						cast('ast.Tuple', cast('ast.Subscript', cast('ast.AnnAssign', ImaAnnAssign).annotation).slice).elts = list_exprDOTannotation
+						cast('ast.Tuple', ImaAnnAssign.value).elts = list_exprDOTvalue
 
 				ingredientsFunction.astFunctionDef.body.insert(0, ImaAnnAssign)
 
-			findThis = IfThis.is_argIdentifier(ast_arg.arg)
-			remove_arg = NodeChanger(findThis, Then.removeIt)
+			findThis: Callable[[ast.AST], TypeIs[ast.arg] | bool] = IfThis.is_argIdentifier(ast_arg.arg)
+			remove_arg: NodeChanger[ast.arg, None] = NodeChanger(findThis, Then.removeIt)
 			remove_arg.visit(ingredientsFunction.astFunctionDef)
 
 	ast.fix_missing_locations(ingredientsFunction.astFunctionDef)
@@ -186,6 +204,8 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 def makeJobNumba(job: RecipeJobTheorem2Numba, spices: SpicesJobNumba) -> None:
 	"""Generate an optimized Numba-compiled computation module for map folding calculations.
 
+	(AI generated docstring)
+
 	This function orchestrates the complete code transformation pipeline to convert
 	a generic map folding algorithm into a highly optimized, specialized computation
 	module. The transformation process includes:
@@ -203,26 +223,25 @@ def makeJobNumba(job: RecipeJobTheorem2Numba, spices: SpicesJobNumba) -> None:
 	map folding calculations for the specific map dimensions with maximum
 	performance through just-in-time compilation.
 
-	Parameters:
-		job: Configuration recipe containing source locations, target paths, and state.
-		spices: Optimization settings including Numba parameters and progress options.
-	"""
+	Parameters
+	----------
+	job : RecipeJobTheorem2Numba
+		Configuration recipe containing source locations, target paths, and state.
+	spices : SpicesJobNumba
+		Optimization settings including Numba parameters and progress options.
 
+	"""
 	astFunctionDef: ast.FunctionDef = raiseIfNone(extractFunctionDef(job.source_astModule, job.countCallable))
 	ingredientsCount: IngredientsFunction = IngredientsFunction(astFunctionDef, LedgerOfImports())
 
 	# Remove `foldGroups` and any other unused statements, so you can dynamically determine which variables are not used
-	findThis = ClassIsAndAttribute.targetsIs(ast.Assign, lambda list_expr: any([IfThis.isSubscriptIdentifier('foldGroups')(node) for node in list_expr ]))
-	# findThis = IfThis.isAssignAndTargets0Is(IfThis.isSubscriptIdentifier('foldGroups'))
-	doThat = Then.removeIt
-	remove_foldGroups = NodeChanger(findThis, doThat)
-	# remove_foldGroups.visit(ingredientsCount.astFunctionDef)
+	# NodeChanger[ast.Name, None](Be.Assign.targetsIs(lambda list_expr: any(IfThis.isSubscriptIdentifier('foldGroups')(node) for node in list_expr)) , Then.removeIt).visit(ingredientsCount.astFunctionDef)  # noqa: ERA001
 
 	# replace identifiers with static values with their values, so you can dynamically determine which variables are not used
 	listIdentifiersStaticValues: list[str] = listIdentifiersStaticValuesHARDCODED
 	for identifier in listIdentifiersStaticValues:
-		findThis = IfThis.isNameIdentifier(identifier)
-		doThat = Then.replaceWith(Make.Constant(int(job.state.__dict__[identifier])))
+		findThis: Callable[[ast.AST], TypeIs[ast.Name] | bool] = IfThis.isNameIdentifier(identifier)
+		doThat: Callable[[ast.Name], ast.Constant] = Then.replaceWith(Make.Constant(int(job.state.__dict__[identifier])))
 		NodeChanger(findThis, doThat).visit(ingredientsCount.astFunctionDef)
 
 	ingredientsModule = IngredientsModule()
@@ -242,8 +261,8 @@ if __name__ == '__main__':
 	writeStream.write(str(foldsTotal))
 	writeStream.close()
 """
-	# from mapFolding.oeis import getFoldsTotalKnown
-	# print(foldsTotal == getFoldsTotalKnown({job.state.mapShape}))
+	# from mapFolding.oeis import getFoldsTotalKnown  # noqa: ERA001
+	# print(foldsTotal == getFoldsTotalKnown({job.state.mapShape}))  # noqa: ERA001
 		ingredientsModule.appendLauncher(ast.parse(linesLaunch))
 		changeReturnParallelCallable = NodeChanger(Be.Return, Then.replaceWith(Make.Return(job.shatteredDataclass.countingVariableName)))
 		changeReturnParallelCallable.visit(ingredientsCount.astFunctionDef)
@@ -258,12 +277,18 @@ if __name__ == '__main__':
 		generation. Each configuration specifies the source module, target type name,
 		and optional import alias for the transformation.
 
-		Attributes:
-			fml: Framework datatype identifier to be replaced.
-			Z0Z_module: Module containing the target datatype (e.g., 'numba', 'numpy').
-			Z0Z_type_name: Concrete type name in the target module.
-			Z0Z_asname: Optional import alias for the type.
+		Attributes
+		----------
+		fml : str
+			Framework datatype identifier to be replaced.
+		Z0Z_module : identifierDotAttribute
+			Module containing the target datatype (e.g., 'numba', 'numpy').
+		Z0Z_type_name : str
+			Concrete type name in the target module.
+		Z0Z_asname : str | None = None
+			Optional import alias for the type.
 		"""
+
 		fml: str
 		Z0Z_module: identifierDotAttribute
 		Z0Z_type_name: str
@@ -296,7 +321,6 @@ if __name__ == '__main__':
 		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)
@@ -326,12 +350,12 @@ if __name__ == '__main__':
 	mapShape = (2,4)
 	state = MapFoldingState(mapShape)
 	state = initializeGroupsOfFolds(state)
-	# foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal
-	# foldsTotalEstimated = dictionaryEstimates[state.mapShape] // state.leavesTotal
+	# foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal  # noqa: ERA001
+	# foldsTotalEstimated = dictionaryEstimates[state.mapShape] // state.leavesTotal  # noqa: ERA001
 	foldsTotalEstimated = 0
 	pathModule = PurePosixPath(packageSettings.pathPackage, 'jobs')
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
 	aJob = RecipeJobTheorem2Numba(state, foldsTotalEstimated, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
 	spices = SpicesJobNumba(useNumbaProgressBar=False, parametersNumba=parametersNumbaLight)
-	# spices = SpicesJobNumba()
+	# spices = SpicesJobNumba()  # noqa: ERA001
 	makeJobNumba(aJob, spices)

mapFolding/someAssemblyRequired/toolkitNumba.py

@@ -26,13 +26,14 @@ system to produce standalone modules optimized for specific map dimensions and c
 """
 
 from astToolkit import identifierDotAttribute, IngredientsFunction, Make
-from collections.abc import Callable, Sequence
-from numba.core.compiler import CompilerBase as numbaCompilerBase
-from typing import Any, cast, Final, NotRequired, TypedDict
+from typing import cast, Final, NotRequired, TYPE_CHECKING, TypedDict
 import ast
 import dataclasses
 import warnings
 
+if TYPE_CHECKING:
+	from collections.abc import Sequence
+
 class ParametersNumba(TypedDict):
 	"""
 	Configuration parameters for Numba compilation decorators.
@@ -56,6 +57,7 @@ class ParametersNumba(TypedDict):
 	optional via `NotRequired`, allowing flexible configuration while requiring explicit
 	decisions on critical performance and correctness parameters.
 	"""
+
 	_dbg_extend_lifetimes: NotRequired[bool]
 	_dbg_optnone: NotRequired[bool]
 	_nrt: NotRequired[bool]
@@ -67,7 +69,7 @@ class ParametersNumba(TypedDict):
 	forceinline: NotRequired[bool]
 	forceobj: NotRequired[bool]
 	inline: NotRequired[str]
-	locals: NotRequired[dict[str, Any]]
+	# locals: NotRequired[dict[str, Any]]
 	looplift: NotRequired[bool]
 	no_cfunc_wrapper: NotRequired[bool]
 	no_cpython_wrapper: NotRequired[bool]
@@ -75,11 +77,11 @@ class ParametersNumba(TypedDict):
 	nogil: NotRequired[bool]
 	nopython: NotRequired[bool]
 	parallel: NotRequired[bool]
-	pipeline_class: NotRequired[type[numbaCompilerBase]]
-	signature_or_function: NotRequired[Any | Callable[..., Any] | str | tuple[Any, ...]]
+	# pipeline_class: NotRequired[type[numbaCompilerBase]]
+	# signature_or_function: NotRequired[Any | Callable[..., Any] | str | tuple[Any, ...]]
 	target: NotRequired[str]
 
-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, }
+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 }
 """
 Comprehensive Numba configuration for maximum performance optimization.
 
@@ -132,54 +134,69 @@ While Numba offers multiple decorators (`@jit`, `@njit`, `@vectorize`), this too
 on the general-purpose `@jit` decorator with configurable parameters for flexibility.
 """
 
-def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, parametersNumba: ParametersNumba | None = None) -> IngredientsFunction:
-	"""
-	Transform a Python function into a Numba-accelerated version with appropriate decorators.
+def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, parametersNumba: ParametersNumba | None = None) -> IngredientsFunction:  # noqa: C901
+	"""Transform a Python function into a Numba-accelerated version with appropriate decorators.
 
-	This function applies Numba's @jit decorator to an existing function definition within
-	an IngredientsFunction container. It handles the complete transformation pipeline:
+	(AI generated docstring)
 
-	1. Removes any existing decorators that might conflict with Numba
-	2. Constructs type signatures for Numba compilation when possible
-	3. Applies the @jit decorator with specified or default parameters
-	4. Updates import requirements to include necessary Numba modules
+	This function applies Numba's `@jit` decorator to an existing function definition within
+	an `IngredientsFunction` container. It handles the complete transformation pipeline
+	including removing any existing decorators that might conflict with Numba, constructing
+	type signatures for Numba compilation when possible, applying the `@jit` decorator with
+	specified or default parameters, and updating import requirements to include necessary
+	Numba modules.
 
 	The transformation preserves function semantics while enabling significant performance
 	improvements through just-in-time compilation. Type inference is attempted for
 	function parameters and return values to enable optimized compilation paths.
-	Parameters:
-		ingredientsFunction: Container holding the function definition and associated metadata
-		parametersNumba: Optional Numba configuration; uses parametersNumbaDefault if None
-	Returns:
-		Modified IngredientsFunction with Numba decorator applied and imports updated
+
+	Parameters
+	----------
+	ingredientsFunction : IngredientsFunction
+		Container holding the function definition and associated metadata.
+	parametersNumba : ParametersNumba | None = None
+		Optional Numba configuration; uses `parametersNumbaDefault` if `None`.
+
+	Returns
+	-------
+	ingredientsFunction : IngredientsFunction
+		Modified `IngredientsFunction` with Numba decorator applied and imports updated.
+
 	"""
 	def Z0Z_UnhandledDecorators(astCallable: ast.FunctionDef) -> ast.FunctionDef:
-		"""
-		Remove existing decorators from function definition to prevent conflicts with Numba.
+		"""Remove existing decorators from function definition to prevent conflicts with Numba.
+
+		(AI generated docstring)
 
 		Numba compilation can be incompatible with certain Python decorators, so this
 		function strips all existing decorators from a function definition before
-		applying the Numba @jit decorator. Removed decorators are logged as warnings
+		applying the Numba `@jit` decorator. Removed decorators are logged as warnings
 		for debugging purposes.
 
 		TODO: Implement more sophisticated decorator handling that can preserve
 		compatible decorators and intelligently handle decorator composition.
 
-		Parameters:
-			astCallable: Function definition AST node to process
+		Parameters
+		----------
+		astCallable : ast.FunctionDef
+			Function definition AST node to process.
+
+		Returns
+		-------
+		astCallable : ast.FunctionDef
+			Function definition with decorator list cleared.
 
-		Returns:
-			astCallable: Function definition with decorator list cleared
 		"""
-		# TODO: more explicit handling of decorators. I'm able to ignore this because I know `algorithmSource` doesn't have any decorators.
+		# TODO more explicit handling of decorators. I'm able to ignore this because I know `algorithmSource` doesn't have any decorators.
 		for decoratorItem in astCallable.decorator_list.copy():
 			astCallable.decorator_list.remove(decoratorItem)
-			warnings.warn(f"Removed decorator {ast.unparse(decoratorItem)} from {astCallable.name}")
+			warnings.warn(f"Removed decorator {ast.unparse(decoratorItem)} from {astCallable.name}", stacklevel=2)
 		return astCallable
 
 	def makeSpecialSignatureForNumba(signatureElement: ast.arg) -> ast.Subscript | ast.Name | None: # pyright: ignore[reportUnusedFunction]
-		"""
-		Generate Numba-compatible type signatures for function parameters.
+		"""Generate Numba-compatible type signatures for function parameters.
+
+		(AI generated docstring)
 
 		This function analyzes function parameter type annotations and converts them into
 		Numba-compatible type signature expressions. It handles various annotation patterns
@@ -189,20 +206,25 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 		The generated signatures enable Numba to perform more efficient compilation by
 		providing explicit type information rather than relying solely on type inference.
 
-		Parameters:
-			signatureElement: Function parameter with type annotation to convert
+		Parameters
+		----------
+		signatureElement : ast.arg
+			Function parameter with type annotation to convert.
+
+		Returns
+		-------
+		ast.Subscript | ast.Name | None
+			Numba-compatible type signature AST node, or None if conversion not possible.
 
-		Returns:
-			Numba-compatible type signature AST node, or None if conversion not possible
 		"""
 		if isinstance(signatureElement.annotation, ast.Subscript) and isinstance(signatureElement.annotation.slice, ast.Tuple):
 			annotationShape: ast.expr = signatureElement.annotation.slice.elts[0]
 			if isinstance(annotationShape, ast.Subscript) and isinstance(annotationShape.slice, ast.Tuple):
 				shapeAsListSlices: list[ast.Slice] = [ast.Slice() for _axis in range(len(annotationShape.slice.elts))]
-				shapeAsListSlices[-1] = ast.Slice(step=ast.Constant(value=1))
-				shapeAST: ast.Slice | ast.Tuple = ast.Tuple(elts=list(shapeAsListSlices), ctx=ast.Load())
+				shapeAsListSlices[-1] = Make.Slice(step=Make.Constant(1))
+				shapeAST: ast.Slice | ast.Tuple = Make.Tuple(list(shapeAsListSlices))
 			else:
-				shapeAST = ast.Slice(step=ast.Constant(value=1))
+				shapeAST = Make.Slice(step=Make.Constant(1))
 
 			annotationDtype: ast.expr = signatureElement.annotation.slice.elts[1]
 			if (isinstance(annotationDtype, ast.Subscript) and isinstance(annotationDtype.slice, ast.Attribute)):
@@ -214,9 +236,9 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 			Z0Z_hacky_dtype: str = ndarrayName
 			datatype_attr = datatypeAST or Z0Z_hacky_dtype
 			ingredientsFunction.imports.addImportFrom_asStr(datatypeModuleDecorator, datatype_attr)
-			datatypeNumba = ast.Name(id=datatype_attr, ctx=ast.Load())
+			datatypeNumba = Make.Name(datatype_attr)
 
-			return ast.Subscript(value=datatypeNumba, slice=shapeAST, ctx=ast.Load())
+			return Make.Subscript(datatypeNumba, slice=shapeAST)
 
 		elif isinstance(signatureElement.annotation, ast.Name):
 			return signatureElement.annotation
@@ -235,14 +257,15 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 
 	if ingredientsFunction.astFunctionDef.returns and isinstance(ingredientsFunction.astFunctionDef.returns, ast.Name):
 		theReturn: ast.Name = ingredientsFunction.astFunctionDef.returns
-		list_argsDecorator = [cast(ast.expr, ast.Call(func=ast.Name(id=theReturn.id, ctx=ast.Load())
-							, args=list_arg4signature_or_function if list_arg4signature_or_function else [], keywords=[] ) )]
+		list_argsDecorator = [cast("ast.expr", Make.Call(Make.Name(theReturn.id)
+							, list_arg4signature_or_function if list_arg4signature_or_function else [], [] ) )]
 	elif list_arg4signature_or_function:
-		list_argsDecorator = [cast(ast.expr, ast.Tuple(elts=list_arg4signature_or_function, ctx=ast.Load()))]
+		list_argsDecorator = [cast("ast.expr", Make.Tuple(list_arg4signature_or_function))]
 
 	ingredientsFunction.astFunctionDef = Z0Z_UnhandledDecorators(ingredientsFunction.astFunctionDef)
 	if parametersNumba is None:
 		parametersNumba = parametersNumbaDefault
+
 	listDecoratorKeywords: list[ast.keyword] = [Make.keyword(parameterName, Make.Constant(parameterValue)) for parameterName, parameterValue in parametersNumba.items()] # pyright: ignore[reportArgumentType]
 
 	decoratorModule = Z0Z_numbaDataTypeModule
@@ -257,8 +280,9 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 
 @dataclasses.dataclass
 class SpicesJobNumba:
-	"""
-	Configuration container for Numba-specific job processing options.
+	"""Configuration container for Numba-specific job processing options.
+
+	(AI generated docstring)
 
 	This dataclass encapsulates configuration settings that control how Numba
 	compilation and execution is applied to job processing functions. It provides
@@ -269,11 +293,17 @@ class SpicesJobNumba:
 	Numba's specialized requirements, enabling consistent application of
 	optimization settings across different computational contexts.
 
-	Attributes:
-		useNumbaProgressBar: Enable progress bar display for long-running computations
-		numbaProgressBarIdentifier: Progress bar implementation identifier
-		parametersNumba: Numba compilation parameters with sensible defaults
+	Attributes
+	----------
+	useNumbaProgressBar : bool
+		Enable progress bar display for long-running computations.
+	numbaProgressBarIdentifier : str
+		Progress bar implementation identifier.
+	parametersNumba : ParametersNumba
+		Numba compilation parameters with sensible defaults.
+
 	"""
+
 	useNumbaProgressBar: bool = True
 	"""Enable progress bar display for Numba-compiled functions with long execution times."""