mapFolding 0.13.0__py3-none-any.whl → 0.13.1__py3-none-any.whl

mapFolding/someAssemblyRequired/RecipeJob.py

@@ -9,7 +9,6 @@ from mapFolding import (
 from mapFolding.someAssemblyRequired import dataclassInstanceIdentifierDEFAULT, ShatteredDataclass
 from mapFolding.someAssemblyRequired.transformationTools import shatter_dataclassesDOTdataclass
 from pathlib import Path, PurePosixPath
-from typing import TypeAlias
 import dataclasses
 
 @dataclasses.dataclass
@@ -134,11 +133,11 @@ class RecipeJobTheorem2:
 	"""Logical path to target dataclass module."""
 
 	# Datatypes ------------------------------------------
-	DatatypeFoldsTotal: TypeAlias = TheDatatypeFoldsTotal
+	type DatatypeFoldsTotal = TheDatatypeFoldsTotal
 	"""Type alias for datatype linked to the magnitude of `foldsTotal`."""
-	DatatypeElephino: TypeAlias = TheDatatypeElephino
+	type DatatypeElephino = TheDatatypeElephino
 	"""Type alias for intermediate computation datatype."""
-	DatatypeLeavesTotal: TypeAlias = TheDatatypeLeavesTotal
+	type DatatypeLeavesTotal = TheDatatypeLeavesTotal
 	"""Type alias for datatype linked to the magnitude of `leavesTotal`."""
 
 	def _makePathFilename(self, pathRoot: PurePosixPath | None = None, logicalPathINFIX: identifierDotAttribute | None = None, filenameStem: str | None = None, fileExtension: str | None = None) -> PurePosixPath:

mapFolding/someAssemblyRequired/_toolkitContainers.py

@@ -217,10 +217,10 @@ class DeReConstructField2ast:
 		self.ast_keyword_field__field = Make.keyword(self.name, self.astName)
 		self.ast_nameDOTname = Make.Attribute(Make.Name(dataclassesDOTdataclassInstanceIdentifier), self.name)
 
-		self.astAnnotation = raiseIfNone(NodeTourist[ast.AnnAssign, ast.Name | None](
+		self.astAnnotation = cast('ast.Name', raiseIfNone(NodeTourist(
 			findThis = Be.AnnAssign.targetIs(IfThis.isNameIdentifier(self.name))
-			, doThat = Then.extractIt(cast("Callable[[ast.AnnAssign], ast.Name | None]", DOT.annotation))
-			).captureLastMatch(dataclassClassDef))
+			, doThat = Then.extractIt(DOT.annotation)
+			).captureLastMatch(dataclassClassDef)))
 
 		self.ast_argAnnotated = Make.arg(self.name, self.astAnnotation)
 

mapFolding/someAssemblyRequired/makeAllModules.py

@@ -299,7 +299,7 @@ def makeDaoOfMapFolding(astModule: ast.Module, moduleIdentifier: str, callableId
 		ingredientsFunctionDispatcher.imports.update(shatteredDataclass.imports)
 		targetCallableIdentifier = ingredientsFunction.astFunctionDef.name
 		ingredientsFunctionDispatcher = unpackDataclassCallFunctionRepackDataclass(ingredientsFunctionDispatcher, targetCallableIdentifier, shatteredDataclass)
-		astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist[ast.Return, ast.expr | None](Be.Return.valueIs(Be.Tuple)
+		astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist(Be.Return.valueIs(Be.Tuple)
 				, doThat=Then.extractIt(DOT.value)).captureLastMatch(ingredientsFunction.astFunctionDef)))
 		astTuple.ctx = ast.Store()
 
@@ -743,7 +743,7 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom) -> None:
 	targetCallableIdentifier = astImportFrom.names[0].name
 	ingredientsFunction = raiseIfNone(unpackDataclassCallFunctionRepackDataclass(ingredientsFunction, targetCallableIdentifier, shatteredDataclass))
 	targetFunctionDef: ast.FunctionDef = raiseIfNone(extractFunctionDef(parseLogicalPath2astModule(raiseIfNone(astImportFrom.module)), targetCallableIdentifier))
-	astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist[ast.Return, ast.expr | None](Be.Return.valueIs(Be.Tuple)
+	astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist(Be.Return.valueIs(Be.Tuple)
 			, doThat=Then.extractIt(DOT.value)).captureLastMatch(targetFunctionDef)))
 	astTuple.ctx = ast.Store()
 

mapFolding/someAssemblyRequired/makeJobTheorem2codon.py

@@ -1,13 +1,14 @@
 """codon.
 
-https://docs.exaloop.io/start/install/"""
+https://docs.exaloop.io/start/install/
+"""
 
 from astToolkit import (
-	Be, DOT, extractFunctionDef, Grab, hasDOTvalue, identifierDotAttribute, IngredientsFunction, IngredientsModule, Make,
-	NodeChanger, NodeTourist, Then)
-from astToolkit.transformationTools import write_astModule
+	Be, DOT, extractFunctionDef, Grab, identifierDotAttribute, IngredientsFunction, IngredientsModule, Make, NodeChanger,
+	NodeTourist, Then)
+from astToolkit.transformationTools import removeUnusedParameters, write_astModule
 from hunterMakesPy import autoDecodingRLE, raiseIfNone
-from mapFolding import getPathFilenameFoldsTotal, MapFoldingState, packageSettings
+from mapFolding import getPathFilenameFoldsTotal, MapFoldingState
 from mapFolding.someAssemblyRequired import IfThis
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
 from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
@@ -44,34 +45,38 @@ class DatatypeConfiguration(NamedTuple):
 # TODO replace with dynamic system. Probably use `Final` in the dataclass.
 listIdentifiersStaticValuesHARDCODED: list[str] = ['dimensionsTotal', 'leavesTotal']
 
-listDatatypeConfigs: list[DatatypeConfiguration] = [
+listDatatypeConfigurations: list[DatatypeConfiguration] = [
 	DatatypeConfiguration(datatypeIdentifier='DatatypeLeavesTotal', typeModule='numpy', typeIdentifier='uint16', type_asname='DatatypeLeavesTotal'),
 	DatatypeConfiguration(datatypeIdentifier='DatatypeElephino', typeModule='numpy', typeIdentifier='uint16', type_asname='DatatypeElephino'),
 	DatatypeConfiguration(datatypeIdentifier='DatatypeFoldsTotal', typeModule='numpy', typeIdentifier='int64', type_asname='DatatypeFoldsTotal'),
 ]
 
-listNumPyTypeConfigs: list[DatatypeConfiguration] = [
+listNumPy_dtype: list[DatatypeConfiguration] = [
 	DatatypeConfiguration(datatypeIdentifier='Array1DLeavesTotal', typeModule='numpy', typeIdentifier='uint16', type_asname='Array1DLeavesTotal'),
 	DatatypeConfiguration(datatypeIdentifier='Array1DElephino', typeModule='numpy', typeIdentifier='uint16', type_asname='Array1DElephino'),
 	DatatypeConfiguration(datatypeIdentifier='Array3D', typeModule='numpy', typeIdentifier='uint16', type_asname='Array3D'),
 ]
 
-def _datatypeDefinitions(ingredientsFunction: IngredientsFunction, ingredientsModule: IngredientsModule) -> tuple[IngredientsFunction, IngredientsModule]:
-	for datatypeConfig in listDatatypeConfigs:
-		ingredientsFunction.imports.removeImportFrom(datatypeConfig.typeModule, None, datatypeConfig.datatypeIdentifier)
-		ingredientsFunction.imports.addImportFrom_asStr(datatypeConfig.typeModule, datatypeConfig.typeIdentifier, datatypeConfig.type_asname)
-		continue
-		ingredientsModule.appendPrologue(statement=Make.Assign([Make.Name(datatypeConfig.datatypeIdentifier, ast.Store())]
-			, value=Make.Name(datatypeConfig.typeIdentifier)
-		))
+def _addWriteFoldsTotal(ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2) -> IngredientsFunction:
+	NodeChanger(Be.Return, Then.removeIt).visit(ingredientsFunction.astFunctionDef)
+	ingredientsFunction.astFunctionDef.returns = Make.Constant(None)
+
+	writeFoldsTotal = Make.Expr(Make.Call(Make.Attribute(
+		Make.Call(Make.Name('open'), listParameters=[Make.Constant(str(job.pathFilenameFoldsTotal.as_posix())), Make.Constant('w')])
+		, 'write'), listParameters=[Make.Call(Make.Name('str'), listParameters=[
+			Make.Mult().join([job.shatteredDataclass.countingVariableName, Make.Constant(job.state.leavesTotal * 2)])])]))
+
+	NodeChanger(IfThis.isAllOf(Be.AugAssign.targetIs(IfThis.isNameIdentifier(job.shatteredDataclass.countingVariableName.id))
+			, Be.AugAssign.opIs(Be.Mult), Be.AugAssign.valueIs(Be.Constant))
+		, doThat=Then.replaceWith(writeFoldsTotal)
+	).visit(ingredientsFunction.astFunctionDef)
+
+	return ingredientsFunction
 
-	for datatypeConfig in listNumPyTypeConfigs:
+def _datatypeDefinitions(ingredientsFunction: IngredientsFunction, ingredientsModule: IngredientsModule) -> tuple[IngredientsFunction, IngredientsModule]:
+	for datatypeConfig in [*listDatatypeConfigurations, *listNumPy_dtype]:
 		ingredientsFunction.imports.removeImportFrom(datatypeConfig.typeModule, None, datatypeConfig.datatypeIdentifier)
 		ingredientsFunction.imports.addImportFrom_asStr(datatypeConfig.typeModule, datatypeConfig.typeIdentifier, datatypeConfig.type_asname)
-		continue
-		ingredientsModule.appendPrologue(statement=Make.Assign([Make.Name(datatypeConfig.datatypeIdentifier, ast.Store())]
-			, value=Make.Name(datatypeConfig.typeIdentifier)
-		))
 
 	ingredientsFunction.imports.removeImportFromModule('mapFolding.dataBaskets')
 
@@ -82,104 +87,60 @@ def _pythonCode2expr(string: str) -> ast.expr:
 	return raiseIfNone(NodeTourist(Be.Expr, Then.extractIt(DOT.value)).captureLastMatch(ast.parse(string)))
 
 def _variableCompatibility(ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2) -> IngredientsFunction:
+	# On some assignment or comparison values, add a type constructor to ensure compatibility.
+	# On some values-as-indexer, add a type constructor to ensure indexing-method compatibility.
 	for ast_arg in job.shatteredDataclass.list_argAnnotated4ArgumentsSpecification:
 		identifier = ast_arg.arg
 		annotation = raiseIfNone(ast_arg.annotation)
 
-		# `identifier` in Augmented Assignment.
-		NodeChanger(Be.AugAssign.targetIs(IfThis.isNestedNameIdentifier(identifier))
-			, doThat=lambda node: Grab.valueAttribute(Then.replaceWith(Make.Call(annotation, listParameters=[node.value])))(node)
-		).visit(ingredientsFunction.astFunctionDef)
-
-		# `identifier` in Assignments; exclude `numpy.array`.
-		NodeChanger(findThis=lambda node: IfThis.isAssignAndTargets0Is(IfThis.isNameIdentifier(identifier))(node)
-			and Be.Assign.valueIs(Be.Constant)(node)
-			, doThat=lambda node: Grab.valueAttribute(Then.replaceWith(Make.Call(annotation, listParameters=[node.value])))(node)
+		# `identifier` in Augmented Assignment, or in Assignments and value is Constant.
+		NodeChanger(findThis=IfThis.isAnyOf(
+				Be.AugAssign.targetIs(IfThis.isNestedNameIdentifier(identifier))
+				, IfThis.isAllOf(IfThis.isAssignAndTargets0Is(IfThis.isNameIdentifier(identifier))
+					, Be.Assign.valueIs(Be.Constant))
+			)
+			, doThat=lambda node, annotation=annotation: Grab.valueAttribute(Then.replaceWith(Make.Call(annotation, listParameters=[node.value])))(node)
 		).visit(ingredientsFunction.astFunctionDef)
 
 		# `identifier` - 1.
 		NodeChanger(Be.BinOp.leftIs(IfThis.isNestedNameIdentifier(identifier))
-			, doThat=lambda node: Grab.rightAttribute(Then.replaceWith(Make.Call(annotation, listParameters=[node.right])))(node)
+			, doThat=lambda node, annotation=annotation: Grab.rightAttribute(Then.replaceWith(Make.Call(annotation, listParameters=[node.right])))(node)
 		).visit(ingredientsFunction.astFunctionDef)
 
 		# `identifier` in Comparison.
 		NodeChanger(Be.Compare.leftIs(IfThis.isNestedNameIdentifier(identifier))
-			, doThat=lambda node: Grab.comparatorsAttribute(lambda at: Then.replaceWith([Make.Call(annotation, listParameters=[node.comparators[0]])])(at[0]))(node)
+			, doThat=lambda node, annotation=annotation: Grab.comparatorsAttribute(lambda at, annotation=annotation: Then.replaceWith([Make.Call(annotation, listParameters=[node.comparators[0]])])(at[0]))(node)
 		).visit(ingredientsFunction.astFunctionDef)
 
 		# `identifier` has exactly one index value.
-		NodeChanger(
-			findThis=lambda node: Be.Subscript.valueIs(IfThis.isNestedNameIdentifier(identifier))(node)
-			and not Be.Subscript.sliceIs(Be.Tuple)(node)
+		NodeChanger(IfThis.isAllOf(Be.Subscript.valueIs(IfThis.isNestedNameIdentifier(identifier))
+			, lambda node: not Be.Subscript.sliceIs(Be.Tuple)(node))
 			, doThat=lambda node: Grab.sliceAttribute(Then.replaceWith(Make.Call(Make.Name('int'), listParameters=[node.slice])))(node)
 		).visit(ingredientsFunction.astFunctionDef)
 
 		# `identifier` has multiple index values.
-		NodeChanger(
-			findThis=lambda node: Be.Subscript.valueIs(IfThis.isNestedNameIdentifier(identifier))(node)
-			and Be.Subscript.sliceIs(Be.Tuple)(node)
+		NodeChanger(IfThis.isAllOf(Be.Subscript.valueIs(IfThis.isNestedNameIdentifier(identifier))
+			, Be.Subscript.sliceIs(Be.Tuple))
 			, doThat=lambda node: Grab.sliceAttribute(Grab.eltsAttribute(
 				Then.replaceWith([
-					Make.Call(Make.Name('int'), listParameters=[cast(ast.Tuple, node.slice).elts[index]])
-					for index in range(len(cast(ast.Tuple, node.slice).elts))
-					])
-			))(node)
+					Make.Call(Make.Name('int'), listParameters=[cast('ast.Tuple', node.slice).elts[index]])
+					for index in range(len(cast('ast.Tuple', node.slice).elts))])))(node)
 		).visit(ingredientsFunction.astFunctionDef)
 
 	return ingredientsFunction
 
-def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2) -> IngredientsFunction:
-	"""Convert function parameters into initialized variables with concrete values.
-
-	This function converts function arguments into statically initialized variables in the function body.
-
-	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.
-
-	Parameters
-	----------
-	ingredientsFunction : IngredientsFunction
-		The function to transform.
-	job : RecipeJobTheorem2
-		Recipe containing concrete values for parameters and field metadata.
-
-	Returns
-	-------
-	modifiedFunction : IngredientsFunction
-		The modified function with parameters converted to initialized variables.
-
-	"""
-	ingredientsFunction.imports.update(job.shatteredDataclass.imports)
-
-	list_argCuzMyBrainRefusesToThink: list[ast.arg] = ingredientsFunction.astFunctionDef.args.args + ingredientsFunction.astFunctionDef.args.posonlyargs + ingredientsFunction.astFunctionDef.args.kwonlyargs
-	list_arg_arg: list[str] = [ast_arg.arg for ast_arg in list_argCuzMyBrainRefusesToThink]
-	listName: list[ast.Name] = []
-	NodeTourist(Be.Name, Then.appendTo(listName)).visit(ingredientsFunction.astFunctionDef)
-	listIdentifiers: list[str] = [astName.id for astName in listName]
-	listIdentifiersNotUsed: list[str] = list(set(list_arg_arg) - set(listIdentifiers))
-
-	for ast_arg in list_argCuzMyBrainRefusesToThink:
-		if ast_arg.arg in job.shatteredDataclass.field2AnnAssign:
-			if ast_arg.arg in listIdentifiersNotUsed:
-				pass
-			else:
-				Ima___Assign, elementConstructor = job.shatteredDataclass.Z0Z_field2AnnAssign[ast_arg.arg]
-				match elementConstructor:
-					case 'scalar':
-						cast('ast.Constant', cast('ast.Call', Ima___Assign.value).args[0]).value = int(job.state.__dict__[ast_arg.arg])
-					case 'array':
-						dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[ast_arg.arg], assumeAddSpaces=True)
-						dataAs_ast_expr: ast.expr = _pythonCode2expr(dataAsStrRLE)
-						cast('ast.Call', Ima___Assign.value).args = [dataAs_ast_expr]
-					case _:
-						pass
-
-				ingredientsFunction.astFunctionDef.body.insert(0, Ima___Assign)
-
-			NodeChanger(IfThis.is_argIdentifier(ast_arg.arg), Then.removeIt).visit(ingredientsFunction.astFunctionDef)
-
-	ast.fix_missing_locations(ingredientsFunction.astFunctionDef)
-	return ingredientsFunction
+def _move_arg2body(identifier: str, job: RecipeJobTheorem2) -> ast.AnnAssign | ast.Assign:
+	Ima___Assign, elementConstructor = job.shatteredDataclass.Z0Z_field2AnnAssign[identifier]
+	match elementConstructor:
+		case 'scalar':
+			cast('ast.Constant', cast('ast.Call', Ima___Assign.value).args[0]).value = int(job.state.__dict__[identifier])
+		case 'array':
+			dataAsStrRLE: str = autoDecodingRLE(job.state.__dict__[identifier], assumeAddSpaces=True)
+			dataAs_ast_expr: ast.expr = _pythonCode2expr(dataAsStrRLE)
+			cast('ast.Call', Ima___Assign.value).args = [dataAs_ast_expr]
+		case _:
+			pass
+	return Ima___Assign
 
 def makeJob(job: RecipeJobTheorem2) -> None:
 	"""Generate an optimized module for map folding calculations.
@@ -204,53 +165,32 @@ def makeJob(job: RecipeJobTheorem2) -> None:
 			, Then.replaceWith(Make.Constant(int(job.state.__dict__[identifier])))
 		).visit(ingredientsCount.astFunctionDef)
 
-	linesLaunch: str = f"""
-if __name__ == '__main__':
-	foldsTotal = {job.countCallable}()
-	print('\\nmap {job.state.mapShape} =', foldsTotal)
-	writeStream = open('{job.pathFilenameFoldsTotal.as_posix()}', 'w')
-	writeStream.write(str(foldsTotal))
-	writeStream.close()
-"""
-	ingredientsModule = IngredientsModule(launcher=ast.parse(linesLaunch))
+	ingredientsCount.imports.update(job.shatteredDataclass.imports)
+	ingredientsCount = removeUnusedParameters(ingredientsCount)
+	NodeChanger(Be.arg, lambda removeIt: ingredientsCount.astFunctionDef.body.insert(0, _move_arg2body(removeIt.arg, job))).visit(ingredientsCount.astFunctionDef)
 
-	# TODO think about `groupsOfFolds *= DatatypeFoldsTotal({2 * job.state.leavesTotal}); return groupsOfFolds`
-	NodeChanger(Be.Return
-		, Then.replaceWith(Make.Return(job.shatteredDataclass.countingVariableName))).visit(ingredientsCount.astFunctionDef)
-	groupsOfFolds2foldsTotal = NodeChanger[ast.AugAssign, hasDOTvalue](
-		findThis=(lambda node: Be.AugAssign.targetIs(IfThis.isNameIdentifier(job.shatteredDataclass.countingVariableName.id))(node)
-			and Be.AugAssign.opIs(Be.Mult)(node)
-			and Be.AugAssign.valueIs(Be.Constant)(node)
-		)
-		, doThat=lambda node: Grab.valueAttribute(Then.replaceWith(Make.Constant(job.state.leavesTotal * ast.literal_eval(node.value))))(node)
-	)
-	groupsOfFolds2foldsTotal.visit(ingredientsCount.astFunctionDef)
-
-	# TODO think about assigning `returns` here, then removing `returns` a few lines from now.
-	ingredientsCount.astFunctionDef.returns = job.shatteredDataclass.countingVariableAnnotation
+	ingredientsCount = _addWriteFoldsTotal(ingredientsCount, job)
+	ingredientsCount = _variableCompatibility(ingredientsCount, job)
 
-	ingredientsCount = move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsCount, job)
+	ingredientsModule = IngredientsModule(launcher=Make.Module([
+		Make.If(Make.Compare(Make.Name('__name__'), [Make.Eq()], [Make.Constant('__main__')])
+			, body=[Make.Expr(Make.Call(Make.Name(job.countCallable)))])]))
 
 	ingredientsCount, ingredientsModule = _datatypeDefinitions(ingredientsCount, ingredientsModule)
-	# NOTE Reminder, `returns = None` means "type information is null"; the identifier for the return was removed by `_datatypeDefinitions`.
-	ingredientsCount.astFunctionDef.returns = None
-
-	ingredientsCount = _variableCompatibility(ingredientsCount, job)
 
 	ingredientsModule.appendIngredientsFunction(ingredientsCount)
 	write_astModule(ingredientsModule, pathFilename=job.pathFilenameModule, packageName=job.packageIdentifier)
 
 	if sys.platform == 'linux':
-		pathFilenameBuild = Path.home() / 'mapFolding' / 'jobs' / job.pathFilenameModule.stem
-		pathFilenameBuild.parent.mkdir(parents=True, exist_ok=True)
-
-		buildCommand = ['codon', 'build', '-release', '-disable-exceptions', '-o', str(pathFilenameBuild), str(job.pathFilenameModule)]
-		subprocess.run(buildCommand)
+		buildCommand: list[str] = ['codon', 'build', '--exe', '--release',
+			'--fast-math', '--enable-unsafe-fp-math', '--disable-exceptions',
+			str(job.pathFilenameModule)]
+		subprocess.run(buildCommand, check=False)
+		subprocess.run(['/usr/bin/strip', str(job.pathFilenameModule.with_suffix(''))], check=False)
 
 if __name__ == '__main__':
 	state = initializeGroupsOfFolds(MapFoldingState((2,4)))
-	pathModule = PurePosixPath(packageSettings.pathPackage, 'jobs')
-	# TODO put `pathFilenameFoldsTotal` in wsl.
+	pathModule = PurePosixPath(Path.home(), 'mapFolding', 'jobs')
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
 	aJob = RecipeJobTheorem2(state, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
 	makeJob(aJob)

mapFolding/someAssemblyRequired/toolkitNumba.py

@@ -26,7 +26,9 @@ system to produce standalone modules optimized for specific map dimensions and c
 """
 
 from astToolkit import identifierDotAttribute, IngredientsFunction, Make
-from typing import cast, Final, NotRequired, TYPE_CHECKING, TypedDict
+from collections.abc import Callable
+from numba.core.compiler import CompilerBase as numbaCompilerBase
+from typing import Any, Final, NotRequired, TYPE_CHECKING, TypedDict
 import ast
 import dataclasses
 import warnings
@@ -69,7 +71,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]
@@ -77,8 +79,8 @@ 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 }
@@ -257,10 +259,10 @@ 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", Make.Call(Make.Name(theReturn.id)
-							, list_arg4signature_or_function if list_arg4signature_or_function else [], [] ) )]
+		list_argsDecorator = [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", Make.Tuple(list_arg4signature_or_function))]
+		list_argsDecorator = [Make.Tuple(list_arg4signature_or_function)]
 
 	ingredientsFunction.astFunctionDef = Z0Z_UnhandledDecorators(ingredientsFunction.astFunctionDef)
 	if parametersNumba is None:

{mapfolding-0.13.0.dist-info → mapfolding-0.13.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.13.0
+Version: 0.13.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.13.0.dist-info → mapfolding-0.13.1.dist-info}/RECORD

@@ -20,16 +20,16 @@ mapFolding/reference/total_countPlus1vsPlusN.py,sha256=yJZAVLVdoXqHag2_N6_6CT-Q6
 mapFolding/reference/jobsCompleted/__init__.py,sha256=TU93ZGUW1xEkT6d9mQFn_rp5DvRy0ZslEB2Q6MF5ZDc,2596
 mapFolding/reference/jobsCompleted/[2x19]/p2x19.py,sha256=_tvYtfzMWVo2VtUbIAieoscb4N8FFflgTdW4-ljBUuA,19626
 mapFolding/reference/jobsCompleted/p2x19/p2x19.py,sha256=eZEw4Me4ocTt6VXoK2-Sbd5SowZtxRIbN9dZmc7OCVg,6395
-mapFolding/someAssemblyRequired/RecipeJob.py,sha256=Hd1DUMZqfqlQz4jj3eTir5e_xvFW7_O0ILWmNsiQWV8,9913
+mapFolding/someAssemblyRequired/RecipeJob.py,sha256=yGGPHq9JX-Gf7QlJz50EPpkO7sADwGvSZNA1aC_F_PQ,9866
 mapFolding/someAssemblyRequired/__init__.py,sha256=UNDh6O86jT5ywlw9LgeWsUHwOfNvoMJRDAzYXbwCbeM,5779
 mapFolding/someAssemblyRequired/_toolIfThis.py,sha256=VDZC10Xo3E1Y5n6FmaBBbOBR-rinV9DFkpgw8zrDyzg,6339
-mapFolding/someAssemblyRequired/_toolkitContainers.py,sha256=ymqEWH5oO_gNjvRjpRELCzahXfU74fhHZspnv6GGLiE,13680
+mapFolding/someAssemblyRequired/_toolkitContainers.py,sha256=vRmetlZI1Kxhe6qjw7ysHeARn5e6F5hmB6ib2BCRxtE,13614
 mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=tY0-2K0BFkwLAAjSrFJLPoG8CevDHOFc3OH3TxXANzg,2806
 mapFolding/someAssemblyRequired/infoBooth.py,sha256=GWiqnHbqk7te_pvVuk4G_gbFa_W2aeSx19w4pakvqfM,2300
-mapFolding/someAssemblyRequired/makeAllModules.py,sha256=wbZXlKd0dOkLYHGM_I7VYH9r9yZfS6HDBJ702nggDxM,44353
+mapFolding/someAssemblyRequired/makeAllModules.py,sha256=o22qQ35N9M3N3kra16IayOpXMI1bkwVNQ5c04_rxMGw,44295
 mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py,sha256=ZSplXKPwRAbvMA2bvEGcXFdgvuYGBk3Ncxajzk-Zy0A,17170
-mapFolding/someAssemblyRequired/makeJobTheorem2codon.py,sha256=8Epqg6eLLNWr3wvg9sdwv3WILMUtbR-lha8-OZXU-I8,12714
-mapFolding/someAssemblyRequired/toolkitNumba.py,sha256=Wg5CWe2UDeR1Y22loxbcRbPOQn1yHFlD6s4uYPGCYwM,14860
+mapFolding/someAssemblyRequired/makeJobTheorem2codon.py,sha256=06FfCgHJDmNFv8li0v0O82Te8FvlFIOCm4OEMZ1EiRM,10160
+mapFolding/someAssemblyRequired/toolkitNumba.py,sha256=nCCVsGidAlcKRVAvA__hu4bXtat3B-cO9YloKtqOAc4,14919
 mapFolding/someAssemblyRequired/transformationTools.py,sha256=nPGZsvb5GquaCCxdDh_XzNIZYSiVJpWKd7wfhfRvxnk,11512
 mapFolding/syntheticModules/__init__.py,sha256=evVFqhCGa-WZKDiLcnQWjs-Bj34eRnfSLqz_d7dFYZY,83
 mapFolding/syntheticModules/countParallel.py,sha256=OK_IB9w4yy9MMAiGvkei5ezPm_00v2nYjPrQZ_IlELg,7733
@@ -46,9 +46,9 @@ mapFolding/tests/test_filesystem.py,sha256=0rYQ62f4e3HOoymXrxDWbqNEBJQ7DGN8RUOMI
 mapFolding/tests/test_oeis.py,sha256=Sn3jpg6YQJMtAAc1W8Ic2PTbTwSckzBdJnkN1rz_O6w,5834
 mapFolding/tests/test_other.py,sha256=ScBiJ78LnyAaW-RhxcouX6Xw10wgpSdqfvT4LO3WjnQ,4766
 mapFolding/tests/test_tasks.py,sha256=_pr9JRWjjNKA7sww70XvkJJdGPruBVzubM63RmD_Du0,4013
-mapfolding-0.13.0.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-mapfolding-0.13.0.dist-info/METADATA,sha256=S-_yPqTdfIVDdYBVeuUV80YHWW54rfMZiOGXiyJFjQ0,8040
-mapfolding-0.13.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mapfolding-0.13.0.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapfolding-0.13.0.dist-info/top_level.txt,sha256=aG3bjFBoxxuaV3Iu1wZAd241Ubs3cdaJtKYBQBDIjsg,11
-mapfolding-0.13.0.dist-info/RECORD,,
+mapfolding-0.13.1.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapfolding-0.13.1.dist-info/METADATA,sha256=mBuToDW06Q7w6hF6KNus2yvB9FQ-V7Lsd958OEXcYrk,8040
+mapfolding-0.13.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mapfolding-0.13.1.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapfolding-0.13.1.dist-info/top_level.txt,sha256=aG3bjFBoxxuaV3Iu1wZAd241Ubs3cdaJtKYBQBDIjsg,11
+mapfolding-0.13.1.dist-info/RECORD,,