mapFolding 0.7.1__py3-none-any.whl → 0.8.0__py3-none-any.whl

mapFolding/someAssemblyRequired/ingredientsNumba.py

@@ -1,6 +1,8 @@
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
+from mapFolding.someAssemblyRequired import ifThis, IngredientsFunction, Make
 from numba.core.compiler import CompilerBase as numbaCompilerBase
-from typing import Any, TYPE_CHECKING, Final
+from typing import Any, TYPE_CHECKING, Final, cast
+import ast
 
 try:
 	from typing import NotRequired
@@ -98,3 +100,86 @@ parametersNumbaMinimum: Final[ParametersNumba] = {
 		'nopython': False,
 		'forceobj': True,
 		'parallel': False, }
+
+Z0Z_numbaDataTypeModule = 'numba'
+Z0Z_decoratorCallable = 'jit'
+
+def thisIsNumbaDotJit(Ima: ast.AST) -> bool:
+	return ifThis.isCallNamespace_Identifier(Z0Z_numbaDataTypeModule, Z0Z_decoratorCallable)(Ima)
+
+def thisIsJit(Ima: ast.AST) -> bool:
+	return ifThis.isCall_Identifier(Z0Z_decoratorCallable)(Ima)
+
+def thisIsAnyNumbaJitDecorator(Ima: ast.AST) -> bool:
+	return thisIsNumbaDotJit(Ima) or thisIsJit(Ima)
+
+def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, parametersNumba: ParametersNumba | None = None) -> IngredientsFunction:
+	def Z0Z_UnhandledDecorators(astCallable: ast.FunctionDef) -> ast.FunctionDef:
+		# 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():
+			import warnings
+			astCallable.decorator_list.remove(decoratorItem)
+			warnings.warn(f"Removed decorator {ast.unparse(decoratorItem)} from {astCallable.name}")
+		return astCallable
+
+	def makeSpecialSignatureForNumba(signatureElement: ast.arg) -> ast.Subscript | ast.Name | None:
+		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())
+			else:
+				shapeAST = ast.Slice(step=ast.Constant(value=1))
+
+			annotationDtype: ast.expr = signatureElement.annotation.slice.elts[1]
+			if (isinstance(annotationDtype, ast.Subscript) and isinstance(annotationDtype.slice, ast.Attribute)):
+				datatypeAST = annotationDtype.slice.attr
+			else:
+				datatypeAST = None
+
+			ndarrayName = signatureElement.arg
+			Z0Z_hacky_dtype: str = ndarrayName
+			datatype_attr = datatypeAST or Z0Z_hacky_dtype
+			ingredientsFunction.imports.addImportFromStr(datatypeModuleDecorator, datatype_attr)
+			datatypeNumba = ast.Name(id=datatype_attr, ctx=ast.Load())
+
+			return ast.Subscript(value=datatypeNumba, slice=shapeAST, ctx=ast.Load())
+
+		elif isinstance(signatureElement.annotation, ast.Name):
+			return signatureElement.annotation
+		return None
+
+	datatypeModuleDecorator: str = Z0Z_numbaDataTypeModule
+	list_argsDecorator: Sequence[ast.expr] = []
+
+	list_arg4signature_or_function: list[ast.expr] = []
+	for parameter in ingredientsFunction.astFunctionDef.args.args:
+		# Efficient translation of Python scalar types to Numba types https://github.com/hunterhogan/mapFolding/issues/8
+		# For now, let Numba infer them.
+		continue
+		signatureElement: ast.Subscript | ast.Name | None = makeSpecialSignatureForNumba(parameter)
+		if signatureElement:
+			list_arg4signature_or_function.append(signatureElement)
+
+	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=[] ) )]
+	elif list_arg4signature_or_function:
+		list_argsDecorator = [cast(ast.expr, ast.Tuple(elts=list_arg4signature_or_function, ctx=ast.Load()))]
+
+	ingredientsFunction.astFunctionDef = Z0Z_UnhandledDecorators(ingredientsFunction.astFunctionDef)
+	if parametersNumba is None:
+		parametersNumba = parametersNumbaDEFAULT
+	listDecoratorKeywords: list[ast.keyword] = [Make.ast_keyword(parameterName, Make.astConstant(parameterValue)) for parameterName, parameterValue in parametersNumba.items()]
+
+	decoratorModule: str = Z0Z_numbaDataTypeModule
+	decoratorCallable: str = Z0Z_decoratorCallable
+	ingredientsFunction.imports.addImportFromStr(decoratorModule, decoratorCallable)
+	# Leave this line in so that global edits will change it.
+	astDecorator: ast.Call = Make.astCall(Make.astName(decoratorCallable), list_argsDecorator, listDecoratorKeywords)
+	astDecorator: ast.Call = Make.astCall(Make.astName(decoratorCallable), list_astKeywords=listDecoratorKeywords) # type: ignore[no-redef]
+
+	ingredientsFunction.astFunctionDef.decorator_list = [astDecorator]
+	return ingredientsFunction

mapFolding/someAssemblyRequired/synthesizeDataConverters.py

@@ -1,29 +1,30 @@
 from collections.abc import Sequence
 from importlib import import_module
 from inspect import getsource as inspect_getsource
-from pathlib import Path
-from types import ModuleType
-from typing import Any, cast, overload, Literal
-import ast
-import pickle
-from mapFolding.beDRY import ComputationState, outfitCountFolds, validateListDimensions
+from mapFolding.beDRY import outfitCountFolds, validateListDimensions
 from mapFolding.filesystem import getPathFilenameFoldsTotal
 from mapFolding.someAssemblyRequired import (
 	ast_Identifier,
-	executeActionUnlessDescendantMatches,
 	extractClassDef,
 	ifThis,
-	IngredientsFunction,
 	LedgerOfImports,
 	Make,
 	NodeCollector,
 	strDotStrCuzPyStoopid,
 	Then,
+	Z0Z_executeActionUnlessDescendantMatches,
 )
-from mapFolding.theSSOT import getSourceAlgorithm
+from mapFolding.theSSOT import ComputationState, getSourceAlgorithm
+from pathlib import Path
+from types import ModuleType
+from typing import Any, Literal, overload
+import ast
+import pickle
+
+# Would `LibCST` be better than `ast` in some cases? https://github.com/hunterhogan/mapFolding/issues/7
 
 def shatter_dataclassesDOTdataclass(logicalPathModule: strDotStrCuzPyStoopid, dataclass_Identifier: ast_Identifier, instance_Identifier: ast_Identifier
-									) -> tuple[ast.Name, LedgerOfImports, list[ast.AnnAssign], list[ast.Name], list[ast.keyword], ast.Tuple]:
+		)-> tuple[ast.Name, LedgerOfImports, list[ast.AnnAssign], ast.Tuple, list[ast.Name], list[ast.arg], ast.Subscript, ast.Assign, list[ast.keyword]]:
 	"""
 	Parameters:
 		logicalPathModule: gimme string cuz python is stoopid
@@ -37,63 +38,44 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: strDotStrCuzPyStoopid, da
 	if not isinstance(dataclass, ast.ClassDef):
 		raise ValueError(f"I could not find {dataclass_Identifier=} in {logicalPathModule=}.")
 
-	list_astAnnAssign: list[ast.AnnAssign] = []
-	listKeywordForDataclassInitialization: list[ast.keyword] = []
-	list_astNameDataclassFragments: list[ast.Name] = []
-	ledgerDataclassAndFragments = LedgerOfImports()
+	ledgerDataclassANDFragments = LedgerOfImports()
+	list_ast_argAnnotated4ArgumentsSpecification: list[ast.arg] = []
+	list_keyword4DataclassInitialization: list[ast.keyword] = []
+	listAnnAssign4DataclassUnpack: list[ast.AnnAssign] = []
+	listAnnotations: list[ast.expr] = []
+	listNameDataclassFragments4Parameters: list[ast.Name] = []
 
 	addToLedgerPredicate = ifThis.isAnnAssignAndAnnotationIsName
-	addToLedgerAction = Then.Z0Z_ledger(logicalPathModule, ledgerDataclassAndFragments)
+	addToLedgerAction = Then.Z0Z_ledger(logicalPathModule, ledgerDataclassANDFragments)
 	addToLedger = NodeCollector(addToLedgerPredicate, [addToLedgerAction])
 
 	exclusionPredicate = ifThis.is_keyword_IdentifierEqualsConstantValue('init', False)
-	appendKeywordAction = Then.Z0Z_appendKeywordMirroredTo(listKeywordForDataclassInitialization)
-	filteredAppendKeywordAction = executeActionUnlessDescendantMatches(exclusionPredicate, appendKeywordAction)
+	appendKeywordAction = Then.Z0Z_appendKeywordMirroredTo(list_keyword4DataclassInitialization)
+	filteredAppendKeywordAction = Z0Z_executeActionUnlessDescendantMatches(exclusionPredicate, appendKeywordAction) # type: ignore
 
 	collector = NodeCollector(
 			ifThis.isAnnAssignAndTargetIsName,
-				[Then.Z0Z_appendAnnAssignOfNameDOTnameTo(instance_Identifier, list_astAnnAssign)
-				, Then.append_targetTo(list_astNameDataclassFragments)
+				[Then.Z0Z_appendAnnAssignOf_nameDOTnameTo(instance_Identifier, listAnnAssign4DataclassUnpack)
+				, Then.append_targetTo(listNameDataclassFragments4Parameters) # type: ignore
 				, lambda node: addToLedger.visit(node)
 				, filteredAppendKeywordAction
+				, lambda node: list_ast_argAnnotated4ArgumentsSpecification.append(Make.ast_arg(node.target.id, node.annotation)) # type: ignore
+				, lambda node: listAnnotations.append(node.annotation) # type: ignore
 				]
 			)
 
 	collector.visit(dataclass)
 
-	ledgerDataclassAndFragments.addImportFromStr(logicalPathModule, dataclass_Identifier)
-
-	astNameDataclass = Make.astName(dataclass_Identifier)
-	astTupleForAssignTargetsToFragments: ast.Tuple = Make.astTuple(list_astNameDataclassFragments, ast.Store())
-	return astNameDataclass, ledgerDataclassAndFragments, list_astAnnAssign, list_astNameDataclassFragments, listKeywordForDataclassInitialization, astTupleForAssignTargetsToFragments
-
-def makeDataclassConverter(dataclassIdentifier: str,
-		logicalPathModuleDataclass: str,
-		dataclassInstance: str,
-		dispatcherCallable: str,
-		logicalPathModuleDispatcher: str,
-		dataConverterCallable: str,
-		) -> IngredientsFunction:
-
-	astNameDataclass, ledgerDataclassAndFragments, list_astAnnAssign, list_astNameDataclassFragments, list_astKeywordDataclassFragments, astTupleForAssignTargetsToFragments = shatter_dataclassesDOTdataclass(logicalPathModuleDataclass, dataclassIdentifier, dataclassInstance)
-
-	ingredientsFunction = IngredientsFunction(
-		FunctionDef = Make.astFunctionDef(name=dataConverterCallable
-										, argumentsSpecification=Make.astArgumentsSpecification(args=[Make.astArg(dataclassInstance, astNameDataclass)])
-										, body = cast(list[ast.stmt], list_astAnnAssign)
-										, returns = astNameDataclass
-										)
-		, imports = ledgerDataclassAndFragments
-	)
-
-	callToDispatcher = Make.astAssign(listTargets=[astTupleForAssignTargetsToFragments]
-										, value=Make.astCall(Make.astName(dispatcherCallable), args=list_astNameDataclassFragments))
-	ingredientsFunction.FunctionDef.body.append(callToDispatcher)
-	ingredientsFunction.imports.addImportFromStr(logicalPathModuleDispatcher, dispatcherCallable)
+	astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns = Make.astSubscript(Make.astName('tuple'), Make.astTuple(listAnnotations))
 
-	ingredientsFunction.FunctionDef.body.append(Make.astReturn(Make.astCall(astNameDataclass, list_astKeywords=list_astKeywordDataclassFragments)))
+	ledgerDataclassANDFragments.addImportFromStr(logicalPathModule, dataclass_Identifier)
 
-	return ingredientsFunction
+	astName_dataclassesDOTdataclass = Make.astName(dataclass_Identifier)
+	astTuple4AssignTargetsToFragments: ast.Tuple = Make.astTuple(listNameDataclassFragments4Parameters, ast.Store())
+	astAssignDataclassRepack = Make.astAssign(listTargets=[Make.astName(instance_Identifier)], value=Make.astCall(astName_dataclassesDOTdataclass, list_astKeywords=list_keyword4DataclassInitialization))
+	return (astName_dataclassesDOTdataclass, ledgerDataclassANDFragments, listAnnAssign4DataclassUnpack,
+			astTuple4AssignTargetsToFragments, listNameDataclassFragments4Parameters, list_ast_argAnnotated4ArgumentsSpecification,
+			astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns, astAssignDataclassRepack, list_keyword4DataclassInitialization)
 
 @overload
 def makeStateJob(listDimensions: Sequence[int], *, writeJob: Literal[True], **keywordArguments: Any) -> Path: ...
@@ -116,11 +98,11 @@ def makeStateJob(listDimensions: Sequence[int], *, writeJob: bool = True, **keyw
 			the path to the saved state file if writeJob is True.
 	"""
 	mapShape = validateListDimensions(listDimensions)
-	stateUniversal = outfitCountFolds(mapShape, **keywordArguments)
+	stateUniversal: ComputationState = outfitCountFolds(mapShape, **keywordArguments)
 
 	moduleSource: ModuleType = getSourceAlgorithm()
 	# TODO `countInitialize` is hardcoded
-	stateUniversal: ComputationState = moduleSource.countInitialize(stateUniversal)
+	stateUniversal = moduleSource.countInitialize(stateUniversal)
 
 	if not writeJob:
 		return stateUniversal

mapFolding/someAssemblyRequired/{synthesizeNumbaJob.py → synthesizeNumbaJobVESTIGIAL.py}

@@ -2,8 +2,9 @@
 from collections.abc import Sequence
 from typing import Any, cast, TYPE_CHECKING
 from mapFolding.filesystem import getFilenameFoldsTotal, getPathFilenameFoldsTotal
-from mapFolding.someAssemblyRequired import ( ifThis, Make, NodeReplacer, Then, LedgerOfImports, )
-from mapFolding.theSSOT import ( ComputationState, FREAKOUT, getPathJobRootDEFAULT, )
+from mapFolding.someAssemblyRequired import ( ifThis, Make, NodeReplacer, Then, )
+from mapFolding.someAssemblyRequired.transformationTools import LedgerOfImports
+from mapFolding.theSSOT import ( ComputationState, raiseIfNoneGitHubIssueNumber3, getPathJobRootDEFAULT, )
 from os import PathLike
 from pathlib import Path
 from types import ModuleType
@@ -16,8 +17,8 @@ import inspect
 import numpy
 if TYPE_CHECKING:
 	from mapFolding.someAssemblyRequired.synthesizeDataConverters import makeStateJob
-	from mapFolding.someAssemblyRequired.synthesizeNumba import thisIsNumbaDotJit, decorateCallableWithNumba
-	from mapFolding.someAssemblyRequired.whatWillBe import ParametersNumba, Z0Z_getDatatypeModuleScalar, Z0Z_getDecoratorCallable, Z0Z_setDatatypeModuleScalar, Z0Z_setDecoratorCallable, parametersNumbaDEFAULT
+	from mapFolding.someAssemblyRequired.ingredientsNumba import thisIsNumbaDotJit, decorateCallableWithNumba
+	from mapFolding.someAssemblyRequired.ingredientsNumba import ParametersNumba, parametersNumbaDEFAULT
 
 def Z0Z_gamma(FunctionDefTarget: ast.FunctionDef, astAssignee: ast.Name, statement: ast.Assign | ast.stmt, identifier: str, arrayTarget: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.integer[Any]]], allImports: LedgerOfImports) -> tuple[ast.FunctionDef, LedgerOfImports]:
 	arrayType = type(arrayTarget)
@@ -53,7 +54,7 @@ def insertArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arra
 
 def findAndReplaceTrackArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arrayTarget: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.integer[Any]]], allImports: LedgerOfImports) -> tuple[ast.FunctionDef, LedgerOfImports]:
 	for statement in FunctionDefTarget.body.copy():
-		if ifThis.isUnpackingAnArray(identifier)(statement):
+		if True:
 			indexAsStr: str = ast.unparse(statement.value.slice) # type: ignore
 			arraySlice: numpy.ndarray[Any, numpy.dtype[numpy.integer[Any]]] = arrayTarget[eval(indexAsStr)]
 			astAssignee: ast.Name = cast(ast.Name, statement.targets[0]) # type: ignore
@@ -62,10 +63,10 @@ def findAndReplaceTrackArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifi
 
 def findAndReplaceArraySubscriptIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arrayTarget: numpy.ndarray[tuple[int, ...], numpy.dtype[numpy.integer[Any]]], allImports: LedgerOfImports) -> tuple[ast.FunctionDef, LedgerOfImports]:
 	# parameter: I define moduleConstructor
-	moduleConstructor = Z0Z_getDatatypeModuleScalar()
+	moduleConstructor = 'numba'
 
 	for statement in FunctionDefTarget.body.copy():
-		if ifThis.isUnpackingAnArray(identifier)(statement):
+		if True:
 			indexAsStr: str = ast.unparse(statement.value.slice) # type: ignore
 			arraySlice: numpy.ndarray[Any, numpy.dtype[numpy.integer[Any]]] = arrayTarget[eval(indexAsStr)]
 			astAssignee: ast.Name = cast(ast.Name, statement.targets[0]) # type: ignore
@@ -83,7 +84,7 @@ def findAndReplaceArraySubscriptIn_body(FunctionDefTarget: ast.FunctionDef, iden
 def removeAssignmentFrom_body(FunctionDefTarget: ast.FunctionDef, identifier: str) -> ast.FunctionDef:
 	FunctionDefSherpa: ast.AST | Sequence[ast.AST] | None = NodeReplacer(ifThis.isAnyAssignmentTo(identifier), Then.removeThis).visit(FunctionDefTarget)
 	if not FunctionDefSherpa:
-		raise FREAKOUT("Dude, where's my function?")
+		raise raiseIfNoneGitHubIssueNumber3("Dude, where's my function?")
 	else:
 		FunctionDefTarget = cast(ast.FunctionDef, FunctionDefSherpa)
 	ast.fix_missing_locations(FunctionDefTarget)
@@ -91,7 +92,7 @@ def removeAssignmentFrom_body(FunctionDefTarget: ast.FunctionDef, identifier: st
 
 def findAndReplaceAnnAssignIn_body(FunctionDefTarget: ast.FunctionDef, allImports: LedgerOfImports) -> tuple[ast.FunctionDef, LedgerOfImports]:
 	"""Unlike most of the other functions, this is generic: it tries to turn an annotation into a construction call."""
-	moduleConstructor: str = Z0Z_getDatatypeModuleScalar()
+	moduleConstructor: str = 'numba'
 	for stmt in FunctionDefTarget.body.copy():
 		if isinstance(stmt, ast.AnnAssign):
 			if isinstance(stmt.target, ast.Name) and isinstance(stmt.value, ast.Constant):
@@ -141,7 +142,7 @@ def insertReturnStatementIn_body(FunctionDefTarget: ast.FunctionDef, arrayTarget
 
 	datatype: str = 'Z0Z_identifierCountFolds'
 	FunctionDefTarget.returns = ast.Name(id=datatype, ctx=ast.Load())
-	datatypeModuleScalar: str = Z0Z_getDatatypeModuleScalar()
+	datatypeModuleScalar: str = 'numba'
 	allImports.addImportFromStr(datatypeModuleScalar, datatype)
 
 	FunctionDefTarget.body.append(returnStatement)
@@ -297,13 +298,13 @@ def writeJobNumba(mapShape: Sequence[int], algorithmSource: ModuleType, callable
 
 	if not callableTarget:
 		if len(setFunctionDef) == 1:
-			FunctionDefTarget: ast.FunctionDef | None = setFunctionDef.pop()
+			FunctionDefTarget = setFunctionDef.pop()
 			callableTarget = FunctionDefTarget.name
 		else:
 			raise ValueError(f"I did not receive a `callableTarget` and {algorithmSource.__name__=} has more than one callable: {setFunctionDef}. Please select one.")
 	else:
 		listFunctionDefTarget: list[ast.FunctionDef] = [statement for statement in setFunctionDef if statement.name == callableTarget]
-		FunctionDefTarget = listFunctionDefTarget[0] if listFunctionDefTarget else None
+		FunctionDefTarget = listFunctionDefTarget[0] if listFunctionDefTarget else None # type: ignore
 	if not FunctionDefTarget: raise ValueError(f"I received `{callableTarget=}` and {algorithmSource.__name__=}, but I could not find that function in that source.")
 
 	# NOTE `allImports` is a complementary container to `FunctionDefTarget`; the `FunctionDefTarget` cannot track its own imports very well.
@@ -323,7 +324,7 @@ def writeJobNumba(mapShape: Sequence[int], algorithmSource: ModuleType, callable
 		FunctionDefTarget.args.args.remove(pirateScowl)
 
 	identifierCounter = 'Z0Z_identifierCountFolds'
-	astExprIncrementCounter = ast.Expr(value = Make.astCall(Make.nameDOTname(identifierCounter, 'update'), args=[ast.Constant(value=1)], list_astKeywords=[]))
+	astExprIncrementCounter = ast.Expr(value = Make.astCall(Make.nameDOTname(identifierCounter, 'update'), listArguments=[ast.Constant(value=1)], list_astKeywords=[]))
 	FunctionDefTarget= cast(ast.FunctionDef, NodeReplacer(ifThis.isAugAssignTo(identifierCounter), Then.replaceWith(astExprIncrementCounter)).visit(FunctionDefTarget))
 	ast.fix_missing_locations(FunctionDefTarget)
 
@@ -344,7 +345,7 @@ def writeJobNumba(mapShape: Sequence[int], algorithmSource: ModuleType, callable
 
 	# TODO create function for assigning value to `totalEstimated`
 	totalEstimated: int = Z0Z_totalEstimated
-	astLauncher: ast.Module = makeLauncherTqdmJobNumba(FunctionDefTarget.name, pathFilenameFoldsTotal, totalEstimated, stateJob.foldGroups[-1])
+	astLauncher = makeLauncherTqdmJobNumba(FunctionDefTarget.name, pathFilenameFoldsTotal, totalEstimated, stateJob.foldGroups[-1])
 
 	allImports.addImportFromStr('numba_progress', 'ProgressBar')
 	allImports.addImportFromStr('numba_progress', 'ProgressBarType')
@@ -361,10 +362,9 @@ def writeJobNumba(mapShape: Sequence[int], algorithmSource: ModuleType, callable
 
 	FunctionDefTarget, allImports = findAndReplaceAnnAssignIn_body(FunctionDefTarget, allImports)
 	# NOTE add the perfect decorator
-	FunctionDefTarget, allImports = decorateCallableWithNumba(FunctionDefTarget, allImports, parametersNumba)
 	if thisIsNumbaDotJit(FunctionDefTarget.decorator_list[0]):
 		astCall: ast.Call = cast(ast.Call, FunctionDefTarget.decorator_list[0])
-		astCall.func = ast.Name(id=Z0Z_getDecoratorCallable(), ctx=ast.Load())
+		astCall.func = ast.Name(id='jit', ctx=ast.Load())
 		FunctionDefTarget.decorator_list[0] = astCall
 
 	# NOTE add imports, make str, remove unused imports
@@ -400,8 +400,8 @@ if __name__ == '__main__':
 	}
 
 	totalEstimated: int = dictionaryEstimates.get(tuple(mapShape), 10**8)
-	from mapFolding.syntheticModules import numbaCount
-	algorithmSource: ModuleType = numbaCount
+	from mapFolding.syntheticModules import numbaCount_doTheNeedful
+	algorithmSource: ModuleType = numbaCount_doTheNeedful
 
 	callableTarget = 'countSequential'
 
@@ -411,7 +411,4 @@ if __name__ == '__main__':
 
 	pathFilenameWriteJob = None
 
-	Z0Z_setDatatypeModuleScalar('numba')
-	Z0Z_setDecoratorCallable('jit')
-
 	writeJobNumba(mapShape, algorithmSource, callableTarget, parametersNumba, pathFilenameWriteJob, Z0Z_totalEstimated=totalEstimated)