mapFolding 0.4.1__py3-none-any.whl → 0.4.3__py3-none-any.whl

mapFolding/someAssemblyRequired/synthesizeNumba.py

@@ -9,10 +9,11 @@ def insertArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arra
 	# NOTE hack
 	constructorName = constructorName.replace('ndarray', 'array')
 	argData_dtype: numpy.dtype = arrayTarget.dtype
-	argData_dtypeName = arrayTarget.dtype.name
+	datatypeName = argData_dtype.name
+	dtypeAsName = f"{moduleConstructor}_{datatypeName}"
 
 	allImports.addImportFromStr(moduleConstructor, constructorName)
-	allImports.addImportFromStr(moduleConstructor, argData_dtypeName)
+	allImports.addImportFromStr(moduleConstructor, datatypeName, dtypeAsName)
 
 	def insertAssign(assignee: str, arraySlice: numpy.ndarray) -> None:
 		nonlocal FunctionDefTarget
@@ -20,7 +21,7 @@ def insertArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arra
 		astStatement = cast(ast.Expr, ast.parse(onlyDataRLE).body[0])
 		dataAst = astStatement.value
 
-		arrayCall = Then.make_astCall(name=constructorName, args=[dataAst], list_astKeywords=[ast.keyword(arg='dtype', value=ast.Name(id=argData_dtypeName, ctx=ast.Load()))])
+		arrayCall = Then.make_astCall(name=constructorName, args=[dataAst], list_astKeywords=[ast.keyword(arg='dtype', value=ast.Name(id=dtypeAsName, ctx=ast.Load()))])
 
 		assignment = ast.Assign(targets=[ast.Name(id=assignee, ctx=ast.Store())], value=arrayCall)#NOTE
 		FunctionDefTarget.body.insert(0, assignment)
@@ -33,7 +34,8 @@ def insertArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arra
 
 	return FunctionDefTarget, allImports
 
-def findAndReplaceArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arrayTarget: numpy.ndarray, allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+def findAndReplaceTrackArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str , arrayTarget: numpy.ndarray , allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+
 	arrayType = type(arrayTarget)
 	moduleConstructor = arrayType.__module__
 	constructorName = arrayType.__name__
@@ -41,47 +43,41 @@ def findAndReplaceArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: s
 	constructorName = constructorName.replace('ndarray', 'array')
 	allImports.addImportFromStr(moduleConstructor, constructorName)
 
-	for stmt in FunctionDefTarget.body.copy():
-		if isinstance(stmt, ast.Assign):
-			if isinstance(stmt.targets[0], ast.Name) and isinstance(stmt.value, ast.Subscript):
-				astAssignee: ast.Name = stmt.targets[0]
-				argData_dtypeName = hackSSOTdatatype(astAssignee.id)
-				allImports.addImportFromStr(moduleConstructor, argData_dtypeName)
-				astSubscript: ast.Subscript = stmt.value
-				if isinstance(astSubscript.value, ast.Name) and astSubscript.value.id == identifier and isinstance(astSubscript.slice, ast.Attribute):
-					indexAs_astAttribute: ast.Attribute = astSubscript.slice
-					indexAsStr = ast.unparse(indexAs_astAttribute)
-					arraySlice = arrayTarget[eval(indexAsStr)]
+	for statement in FunctionDefTarget.body.copy():
+		if ifThis.isUnpackingAnArray(identifier)(statement):
+			datatypeName = hackSSOTdatatype(statement.targets[0].id) # type: ignore
+			dtypeAsName = f"{moduleConstructor}_{datatypeName}"
+			indexAsStr = ast.unparse(statement.value.slice) # type: ignore
+			arraySlice = arrayTarget[eval(indexAsStr)]
 
-					onlyDataRLE = autoDecodingRLE(arraySlice, addSpaces=True)
-					astStatement = cast(ast.Expr, ast.parse(onlyDataRLE).body[0])
-					dataAst = astStatement.value
+			onlyDataRLE = autoDecodingRLE(arraySlice, addSpaces=True)
+			astStatement = cast(ast.Expr, ast.parse(onlyDataRLE).body[0])
+			dataAst = astStatement.value
 
-					arrayCall = Then.make_astCall(name=constructorName, args=[dataAst], list_astKeywords=[ast.keyword(arg='dtype', value=ast.Name(id=argData_dtypeName, ctx=ast.Load()))])
+			arrayCall = Then.make_astCall(name=constructorName, args=[dataAst], list_astKeywords=[ast.keyword(arg='dtype', value=ast.Name(id=dtypeAsName, ctx=ast.Load()))])
 
-					assignment = ast.Assign(targets=[astAssignee], value=arrayCall)
-					FunctionDefTarget.body.insert(0, assignment)
-					FunctionDefTarget.body.remove(stmt)
+			assignment = ast.Assign(targets=[statement.targets[0]], value=arrayCall) # type: ignore
+			FunctionDefTarget.body.insert(0, assignment)
+			FunctionDefTarget.body.remove(statement)
+			allImports.addImportFromStr(moduleConstructor, datatypeName, dtypeAsName)
 	return FunctionDefTarget, allImports
 
 def findAndReplaceArraySubscriptIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arrayTarget: numpy.ndarray, Z0Z_listChaff: List[str], allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
 	moduleConstructor = Z0Z_getDatatypeModuleScalar()
-	for stmt in FunctionDefTarget.body.copy():
-		if isinstance(stmt, ast.Assign):
-			if isinstance(stmt.targets[0], ast.Name) and isinstance(stmt.value, ast.Subscript):
-				astAssignee: ast.Name = stmt.targets[0]
-				argData_dtypeName = hackSSOTdatatype(astAssignee.id)
-				allImports.addImportFromStr(moduleConstructor, argData_dtypeName)
-				astSubscript: ast.Subscript = stmt.value
-				if isinstance(astSubscript.value, ast.Name) and astSubscript.value.id == identifier and isinstance(astSubscript.slice, ast.Attribute):
-					indexAs_astAttribute: ast.Attribute = astSubscript.slice
-					indexAsStr = ast.unparse(indexAs_astAttribute)
-					argDataSlice: int = arrayTarget[eval(indexAsStr)].item()
-					astCall = ast.Call(func=ast.Name(id=argData_dtypeName, ctx=ast.Load()), args=[ast.Constant(value=argDataSlice)], keywords=[])
-					assignment = ast.Assign(targets=[astAssignee], value=astCall)
-					if astAssignee.id not in Z0Z_listChaff:
-						FunctionDefTarget.body.insert(0, assignment)
-					FunctionDefTarget.body.remove(stmt)
+	for statement in FunctionDefTarget.body.copy():
+		if ifThis.isUnpackingAnArray(identifier)(statement):
+			astSubscript: ast.Subscript = statement.value # type: ignore
+			astAssignee: ast.Name = statement.targets[0] # type: ignore
+			argData_dtypeName = hackSSOTdatatype(astAssignee.id)
+			allImports.addImportFromStr(moduleConstructor, argData_dtypeName)
+			indexAs_astAttribute: ast.Attribute = astSubscript.slice # type: ignore
+			indexAsStr = ast.unparse(indexAs_astAttribute)
+			argDataSlice: int = arrayTarget[eval(indexAsStr)].item()
+			astCall = ast.Call(func=ast.Name(id=argData_dtypeName, ctx=ast.Load()), args=[ast.Constant(value=argDataSlice)], keywords=[])
+			assignment = ast.Assign(targets=[astAssignee], value=astCall)
+			if astAssignee.id not in Z0Z_listChaff:
+				FunctionDefTarget.body.insert(0, assignment)
+			FunctionDefTarget.body.remove(statement)
 	return FunctionDefTarget, allImports
 
 def removeAssignTargetFrom_body(FunctionDefTarget: ast.FunctionDef, identifier: str) -> ast.FunctionDef:
@@ -136,13 +132,10 @@ def findThingyReplaceWithConstantIn_body(FunctionDefTarget: ast.FunctionDef, obj
 	return newFunction
 
 def findAstNameReplaceWithConstantIn_body(FunctionDefTarget: ast.FunctionDef, name: str, value: int) -> ast.FunctionDef:
-	def findName(node: ast.AST) -> bool:
-		return isinstance(node, ast.Name) and node.id == name
-
 	def replaceWithConstant(node: ast.AST) -> ast.AST:
 		return ast.copy_location(ast.Constant(value=value), node)
 
-	return cast(ast.FunctionDef, NodeReplacer(findName, replaceWithConstant).visit(FunctionDefTarget))
+	return cast(ast.FunctionDef, NodeReplacer(ifThis.nameIs(name), replaceWithConstant).visit(FunctionDefTarget))
 
 def insertReturnStatementIn_body(FunctionDefTarget: ast.FunctionDef, arrayTarget: numpy.ndarray, allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
 	"""Add multiplication and return statement to function, properly constructing AST nodes."""
@@ -155,6 +148,8 @@ def insertReturnStatementIn_body(FunctionDefTarget: ast.FunctionDef, arrayTarget
 
 	returnStatement = ast.Return(value=multiplyOperation)
 
+	datatype = hackSSOTdatatype(Z0Z_identifierCountFolds)
+	FunctionDefTarget.returns = ast.Name(id=datatype, ctx=ast.Load())
 	datatypeModuleScalar = Z0Z_getDatatypeModuleScalar()
 	allImports.addImportFromStr(datatypeModuleScalar, datatype)
 
@@ -240,9 +235,7 @@ if __name__ == '__main__':
 """
 	return ast.parse(linesLaunch)
 
-def makeAstModuleForOneCallable(pythonSource: str, callableTarget: str, parametersNumba: Optional[ParametersNumba]=None, inlineCallables: Optional[bool]=False , unpackArrays: Optional[bool]=False , allImports: Optional[UniversalImportTracker]=None ) -> str:
-	astModule: ast.Module = ast.parse(pythonSource, type_comments=True)
-
+def makeFunctionDef(astModule: ast.Module, callableTarget: str, parametersNumba: Optional[ParametersNumba]=None, inlineCallables: Optional[bool]=False, unpackArrays: Optional[bool]=False, allImports: Optional[UniversalImportTracker]=None) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
 	if allImports is None:
 		allImports = UniversalImportTracker()
 	for statement in astModule.body:
@@ -252,6 +245,8 @@ def makeAstModuleForOneCallable(pythonSource: str, callableTarget: str, paramete
 	if inlineCallables:
 		dictionaryFunctionDef = {statement.name: statement for statement in astModule.body if isinstance(statement, ast.FunctionDef)}
 		callableInlinerWorkhorse = RecursiveInliner(dictionaryFunctionDef)
+		# NOTE the inliner assumes each function is not called more than once
+		# TODO change the inliner to handle multiple calls to the same function
 		FunctionDefTarget = callableInlinerWorkhorse.inlineFunctionBody(callableTarget)
 	else:
 		FunctionDefTarget = next((node for node in astModule.body if isinstance(node, ast.FunctionDef) and node.name == callableTarget), None)
@@ -269,9 +264,7 @@ def makeAstModuleForOneCallable(pythonSource: str, callableTarget: str, paramete
 			FunctionDefTarget = cast(ast.FunctionDef, unpacker.visit(FunctionDefTarget))
 			ast.fix_missing_locations(FunctionDefTarget)
 
-	astModule = ast.Module(body=cast(List[ast.stmt], allImports.makeListAst() + [FunctionDefTarget]), type_ignores=[])
-	ast.fix_missing_locations(astModule)
-	return ast.unparse(astModule)
+	return FunctionDefTarget, allImports
 
 def decorateCallableWithNumba(FunctionDefTarget: ast.FunctionDef, allImports: UniversalImportTracker, parametersNumba: Optional[ParametersNumba]=None) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
 	def Z0Z_UnhandledDecorators(astCallable: ast.FunctionDef) -> ast.FunctionDef:

mapFolding/someAssemblyRequired/synthesizeNumbaGeneralized.py

@@ -1,7 +1,7 @@
 from mapFolding import (
 	computationState,
 	EnumIndices,
-	formatModuleNameDEFAULT,
+	formatFilenameModuleDEFAULT,
 	FREAKOUT,
 	getAlgorithmDispatcher,
 	getAlgorithmSource,
@@ -36,7 +36,7 @@ from numpy import integer
 from numpy.typing import NDArray
 from types import ModuleType
 from typing import Any, Callable, cast, Dict, List, Optional, Sequence, Set, Tuple, Type, Union
-from Z0Z_tools import autoDecodingRLE
+from Z0Z_tools import autoDecodingRLE, updateExtendPolishDictionaryLists
 import ast
 import autoflake
 import collections
@@ -49,9 +49,41 @@ import numpy
 import os
 import pathlib
 import python_minifier
+import warnings
 
 youOughtaKnow = collections.namedtuple('youOughtaKnow', ['callableSynthesized', 'pathFilenameForMe', 'astForCompetentProgrammers'])
 
+# idk how to use this
+class ASTBodyTransformer:
+	"""
+	A helper class to apply multiple transformations on an AST FunctionDef's body.
+	This abstraction eliminates the need to write repetitive loops for removals,
+	replacements, or insertions.
+	"""
+	def __init__(self, functionDefinition: ast.FunctionDef) -> None:
+		self.functionDefinition = functionDefinition
+
+	def replaceIn_body(self, predicate: Callable[[ast.stmt], bool], replacementBuilder: Callable[[ast.stmt], Optional[ast.stmt]]) -> None:
+		newBody: List[ast.stmt] = []
+		for statement in self.functionDefinition.body:
+			if predicate(statement):
+				replacementStatement = replacementBuilder(statement)
+				if replacementStatement is not None:
+					newBody.append(replacementStatement)
+			else:
+				newBody.append(statement)
+		self.functionDefinition.body = newBody
+
+	def atIndexInsert(self, index: int, statement: ast.stmt) -> None:
+		self.functionDefinition.body.insert(index, statement)
+
+	def removeAllOf(self, predicate: Callable[[ast.stmt], bool]) -> None:
+		self.replaceIn_body(predicate, lambda stmt: None)
+
+	def Z0Z_apply(self) -> ast.FunctionDef:
+		ast.fix_missing_locations(self.functionDefinition)
+		return self.functionDefinition
+
 # Generic
 class ifThis:
 	"""Generic AST node predicate builder."""
@@ -71,10 +103,27 @@ class ifThis:
 	def isCallWithName(callableName: str) -> Callable[[ast.AST], bool]:
 		return lambda node: (isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id == callableName)
 
+	@staticmethod
+	def isAssignTarget(identifier: str):
+		return lambda node: (isinstance(node, ast.Assign)
+								and node.targets
+								and isinstance(node.targets[0], ast.Name)
+								and node.targets[0].id == identifier)
+
 	@staticmethod
 	def anyOf(*predicates: Callable[[ast.AST], bool]) -> Callable[[ast.AST], bool]:
 		return lambda node: any(pred(node) for pred in predicates)
 
+	@staticmethod
+	def isUnpackingAnArray(identifier:str):
+		return lambda node: (isinstance(node, ast.Assign)
+						and  isinstance(node.targets[0], ast.Name)
+						and  isinstance(node.value, ast.Subscript)
+						and  isinstance(node.value.value, ast.Name)
+						and  node.value.value.id == identifier
+						and  isinstance(node.value.slice, ast.Attribute)
+						)
+
 class Then:
 	"""Generic actions."""
 	@staticmethod
@@ -103,9 +152,8 @@ class NodeReplacer(ast.NodeTransformer):
 	None from the replacement builder indicates that the node should be removed.
 
 	Attributes:
-		findMe (Callable[[ast.AST], bool]): A function that determines whether a node should be replaced.
-		nodeReplacementBuilder (Callable[[ast.AST], Optional[ast.AST]]): A function that returns a new node
-			or None to remove the node.
+		findMe: A function that determines whether a node should be replaced.
+		nodeReplacementBuilder: A function that returns a new node or None to remove the node.
 
 	Methods:
 		visit(node: ast.AST) -> Optional[ast.AST]:
@@ -142,19 +190,42 @@ class UniversalImportTracker:
 				self.setImport.add(alias.name)
 		elif isinstance(astImport_, ast.ImportFrom):
 			if astImport_.module is not None:
-				self.dictionaryImportFrom[astImport_.module].update(alias.name for alias in astImport_.names)
+				self.dictionaryImportFrom[astImport_.module].update((alias.name, alias.asname) for alias in astImport_.names)
 
-	def addImportFromStr(self, module: str, name: str) -> None:
-		self.dictionaryImportFrom[module].add(name)
+	def addImportStr(self, module: str) -> None:
+		self.setImport.add(module)
 
-	def addImportStr(self, name: str) -> None:
-		self.setImport.add(name)
+	def addImportFromStr(self, module: str, name: str, asname: Optional[str] = None) -> None:
+		self.dictionaryImportFrom[module].add((name, asname))
 
 	def makeListAst(self) -> List[Union[ast.ImportFrom, ast.Import]]:
-		listAstImportFrom = [ast.ImportFrom(module=module, names=[ast.alias(name=name, asname=None)], level=0) for module, names in self.dictionaryImportFrom.items() for name in names]
-		listAstImport = [ast.Import(names=[ast.alias(name=name, asname=None)]) for name in self.setImport]
+		listAstImportFrom = []
+		for module, setOfNameTuples in sorted(self.dictionaryImportFrom.items()):
+			listAliases = []
+			for name, asname in setOfNameTuples:
+				listAliases.append(ast.alias(name=name, asname=asname))
+			listAstImportFrom.append(ast.ImportFrom(module=module, names=listAliases, level=0))
+
+		listAstImport = [ast.Import(names=[ast.alias(name=name, asname=None)]) for name in sorted(self.setImport)]
 		return listAstImportFrom + listAstImport
 
+	def update(self, *fromTracker: 'UniversalImportTracker') -> None:
+		"""
+		Update this tracker with imports from one or more other trackers.
+
+		Parameters:
+			*fromTracker: One or more UniversalImportTracker objects to merge from.
+		"""
+		# Merge all import-from dictionaries
+		dictionaryMerged = updateExtendPolishDictionaryLists(self.dictionaryImportFrom, *(tracker.dictionaryImportFrom for tracker in fromTracker), destroyDuplicates=True, reorderLists=True)
+
+		# Convert lists back to sets for each module's imports
+		self.dictionaryImportFrom = {module: set(listNames) for module, listNames in dictionaryMerged.items()}
+
+		# Update direct imports
+		for tracker in fromTracker:
+			self.setImport.update(tracker.setImport)
+
 # Intricate and specialized
 class RecursiveInliner(ast.NodeTransformer):
 	"""

mapFolding/someAssemblyRequired/synthesizeNumbaJob.py

@@ -64,6 +64,7 @@ def writeJobNumba(mapShape: Sequence[int]
 	pythonSource = inspect.getsource(algorithmSource)
 	astModule = ast.parse(pythonSource)
 	setFunctionDef = {statement for statement in astModule.body if isinstance(statement, ast.FunctionDef)}
+
 	if not callableTarget:
 		if len(setFunctionDef) == 1:
 			FunctionDefTarget = setFunctionDef.pop()
@@ -71,7 +72,8 @@ def writeJobNumba(mapShape: Sequence[int]
 		else:
 			raise ValueError(f"I did not receive a `callableTarget` and {algorithmSource.__name__=} has more than one callable: {setFunctionDef}. Please select one.")
 	else:
-		FunctionDefTarget = setFunctionDef.pop() if callableTarget in {statement.name for statement in setFunctionDef} else None
+		listFunctionDefTarget = [statement for statement in setFunctionDef if statement.name == callableTarget]
+		FunctionDefTarget = listFunctionDefTarget[0] if listFunctionDefTarget else None
 	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.
@@ -86,13 +88,15 @@ def writeJobNumba(mapShape: Sequence[int]
 			case 'my':
 				FunctionDefTarget, allImports = findAndReplaceArraySubscriptIn_body(FunctionDefTarget, pirateScowl.arg, stateJob[pirateScowl.arg], ['taskIndex', 'dimensionsTotal'], allImports)
 			case 'track':
-				FunctionDefTarget, allImports = findAndReplaceArrayIn_body(FunctionDefTarget, pirateScowl.arg, stateJob[pirateScowl.arg], allImports)
+				FunctionDefTarget, allImports = findAndReplaceTrackArrayIn_body(FunctionDefTarget, pirateScowl.arg, stateJob[pirateScowl.arg], allImports)
 			case 'connectionGraph':
 				FunctionDefTarget, allImports = insertArrayIn_body(FunctionDefTarget, pirateScowl.arg, stateJob[pirateScowl.arg], allImports)
 			case 'gapsWhere':
 				FunctionDefTarget, allImports = insertArrayIn_body(FunctionDefTarget, pirateScowl.arg, stateJob[pirateScowl.arg], allImports)
 			case 'foldGroups':
 				FunctionDefTarget = removeAssignTargetFrom_body(FunctionDefTarget, pirateScowl.arg)
+				# FunctionDefTarget, allImports = insertArrayIn_body(FunctionDefTarget, pirateScowl.arg, stateJob[pirateScowl.arg], allImports)
+				# continue
 		FunctionDefTarget.args.args.remove(pirateScowl)
 
 	# NOTE replace identifiers with static values with their values
@@ -110,8 +114,6 @@ def writeJobNumba(mapShape: Sequence[int]
 	FunctionDefTarget, allImports = insertReturnStatementIn_body(FunctionDefTarget, stateJob['foldGroups'], allImports)
 
 	# NOTE add the perfect decorator
-	datatype = hackSSOTdatatype(Z0Z_identifierCountFolds)
-	FunctionDefTarget.returns = ast.Name(id=datatype, ctx=ast.Load())
 	FunctionDefTarget, allImports = decorateCallableWithNumba(FunctionDefTarget, allImports, parametersNumba)
 	if thisIsNumbaDotJit(FunctionDefTarget.decorator_list[0]):
 		astCall = cast(ast.Call, FunctionDefTarget.decorator_list[0])
@@ -124,21 +126,7 @@ def writeJobNumba(mapShape: Sequence[int]
 	ast.fix_missing_locations(astModule)
 	pythonSource = ast.unparse(astModule)
 	pythonSource = autoflake.fix_code(pythonSource, ['mapFolding', 'numba', 'numpy'])
-	pythonSource = python_minifier.minify(pythonSource, remove_annotations = False,
-		remove_pass = False,
-		remove_literal_statements = False,
-		combine_imports = True,
-		hoist_literals = False,
-		rename_locals = False,
-		rename_globals = False,
-		remove_object_base = False,
-		convert_posargs_to_args = False,
-		preserve_shebang = True,
-		remove_asserts = False,
-		remove_debug = False,
-		remove_explicit_return_none = False,
-		remove_builtin_exception_brackets = False,
-		constant_folding = False)
+	# pythonSource = python_minifier.minify(pythonSource, remove_annotations = False, remove_pass = False, remove_literal_statements = False, combine_imports = True, hoist_literals = False, rename_locals = False, rename_globals = False, remove_object_base = False, convert_posargs_to_args = False, preserve_shebang = True, remove_asserts = False, remove_debug = False, remove_explicit_return_none = False, remove_builtin_exception_brackets = False, constant_folding = False)
 
 	# NOTE put on disk
 	if pathFilenameWriteJob is None:
@@ -155,17 +143,18 @@ def writeJobNumba(mapShape: Sequence[int]
 
 if __name__ == '__main__':
 	mapShape = [5,5]
-	from mapFolding.syntheticModules import numba_countSequential
-	algorithmSource: ModuleType = numba_countSequential
+	from mapFolding.syntheticModules import numbaCount
+	algorithmSource: ModuleType = numbaCount
 
-	callableTarget = None
+	callableTarget = 'countSequential'
 
 	parametersNumba = parametersNumbaDEFAULT
+	parametersNumba['boundscheck'] = True
 
 	pathFilenameWriteJob = None
 
 	setDatatypeFoldsTotal('int64', sourGrapes=True)
-	setDatatypeElephino('uint8', sourGrapes=True)
+	setDatatypeElephino('int16', sourGrapes=True)
 	setDatatypeLeavesTotal('uint8', sourGrapes=True)
 	Z0Z_setDatatypeModuleScalar('numba')
 	Z0Z_setDecoratorCallable('jit')

mapFolding/someAssemblyRequired/synthesizeNumbaModules.py

@@ -4,42 +4,82 @@ everything I am doing. I would rather benefit from humanity's
 collective wisdom."""
 from mapFolding.someAssemblyRequired.synthesizeNumba import *
 
-def makeFlowNumbaOptimized(listCallablesInline: List[str], callableDispatcher: Optional[bool] = False, algorithmSource: Optional[ModuleType] = None, relativePathWrite: Optional[pathlib.Path] = None, formatFilenameWrite: Optional[str] = None) -> List[youOughtaKnow]:
-	if relativePathWrite and relativePathWrite.is_absolute():
-		raise ValueError("The path to write the module must be relative to the root of the package.")
-	if not algorithmSource:
-		algorithmSource = getAlgorithmSource()
+def getFunctionDef(algorithmSource: ModuleType, *arguments, **keywordArguments) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+	pythonSource = inspect.getsource(algorithmSource)
+	astModule: ast.Module = ast.parse(pythonSource, type_comments=True)
+	FunctionDefTarget, allImports = makeFunctionDef(astModule, *arguments, **keywordArguments)
+	return FunctionDefTarget, allImports
 
-	listStuffYouOughtaKnow: List[youOughtaKnow] = []
+def makePythonSource(listFunctionDefs: List[ast.FunctionDef], listAstImports: List[ast.Import|ast.ImportFrom], additional_imports: List[str]) -> str:
+	astModule = ast.Module(body=cast(List[ast.stmt], listAstImports + listFunctionDefs), type_ignores=[])
+	ast.fix_missing_locations(astModule)
+	pythonSource = ast.unparse(astModule)
+	if not pythonSource: raise FREAKOUT
+	pythonSource = autoflake.fix_code(pythonSource, additional_imports)
+	return pythonSource
+
+def writePythonAsModule(pythonSource: str, listCallableSynthesized: List[str], relativePathWrite: Optional[pathlib.Path], filenameWrite: Optional[str], formatFilenameWrite: Optional[str]) -> List[youOughtaKnow]:
+	pathFilename = None
+	if not relativePathWrite:
+		pathWrite = getPathSyntheticModules()
+	else:
+		pathWrite = getPathPackage() / relativePathWrite
 
-	def doThisStuff(callableTarget: str, parametersNumba: Optional[ParametersNumba], inlineCallables: bool, unpackArrays: bool, allImports: Optional[UniversalImportTracker], relativePathWrite: Optional[pathlib.Path], formatFilenameWrite: Optional[str]) -> youOughtaKnow:
-		pythonSource = inspect.getsource(algorithmSource)
-		pythonSource = makeAstModuleForOneCallable(pythonSource, callableTarget, parametersNumba, inlineCallables, unpackArrays, allImports)
-		if not pythonSource: raise FREAKOUT
-		pythonSource = autoflake.fix_code(pythonSource, ['mapFolding', 'numba', 'numpy'])
+	if not formatFilenameWrite:
+		formatFilenameWrite = formatFilenameModuleDEFAULT
 
-		if not relativePathWrite:
-			pathWrite = getPathSyntheticModules()
+	if not filenameWrite:
+		if len(listCallableSynthesized) == 1:
+			callableTarget = listCallableSynthesized[0]
 		else:
-			pathWrite = getPathPackage() / relativePathWrite
-		if not formatFilenameWrite:
-			formatFilenameWrite = formatModuleNameDEFAULT + '.py'
-		pathFilename = pathWrite  / formatFilenameWrite.format(callableTarget=callableTarget)
+			callableTarget = 'count'
+		filenameWrite = formatFilenameWrite.format(callableTarget=callableTarget)
+	else:
+		if not filenameWrite.endswith('.py'):
+			warnings.warn(f"Filename {filenameWrite=} does not end with '.py'.")
 
-		pathFilename.write_text(pythonSource)
+	pathFilename = pathWrite / filenameWrite
 
-		howIsThisStillAThing = getPathPackage().parent
-		dumbassPythonNamespace = pathFilename.relative_to(howIsThisStillAThing).with_suffix('').parts
-		ImaModule = '.'.join(dumbassPythonNamespace)
+	pathFilename.write_text(pythonSource)
+
+	howIsThisStillAThing = getPathPackage().parent
+	dumbassPythonNamespace = pathFilename.relative_to(howIsThisStillAThing).with_suffix('').parts
+	ImaModule = '.'.join(dumbassPythonNamespace)
+
+	listStuffYouOughtaKnow: List[youOughtaKnow] = []
+
+	for callableTarget in listCallableSynthesized:
 		astImportFrom = ast.ImportFrom(module=ImaModule, names=[ast.alias(name=callableTarget, asname=None)], level=0)
+		stuff = youOughtaKnow(callableSynthesized=callableTarget, pathFilenameForMe=pathFilename, astForCompetentProgrammers=astImportFrom)
+		listStuffYouOughtaKnow.append(stuff)
 
-		return youOughtaKnow(callableSynthesized=callableTarget, pathFilenameForMe=pathFilename, astForCompetentProgrammers=astImportFrom)
+	return listStuffYouOughtaKnow
 
+def makeFlowNumbaOptimized(listCallablesInline: List[str]
+							, callableDispatcher: Optional[bool] = False
+							, algorithmSource: Optional[ModuleType] = None
+							, relativePathWrite: Optional[pathlib.Path] = None
+							, filenameModuleWrite: Optional[str] = None
+							, formatFilenameWrite: Optional[str] = None
+							) -> List[youOughtaKnow]:
+	if relativePathWrite and relativePathWrite.is_absolute():
+		raise ValueError("The path to write the module must be relative to the root of the package.")
+	if not algorithmSource:
+		algorithmSource = getAlgorithmSource()
+
+	Z0Z_filenameModuleWrite = 'numbaCount.py'
+
+	listStuffYouOughtaKnow: List[youOughtaKnow] = []
+	additional_imports = ['mapFolding', 'numba', 'numpy']
+
+	listFunctionDefs: List[ast.FunctionDef] = []
+	allImportsModule = UniversalImportTracker()
 	for callableTarget in listCallablesInline:
 		parametersNumba = None
 		inlineCallables = True
 		unpackArrays 	= False
 		allImports 		= None
+		filenameWrite 	= None
 		match callableTarget:
 			case 'countParallel':
 				parametersNumba = parametersNumbaSuperJitParallel
@@ -48,7 +88,17 @@ def makeFlowNumbaOptimized(listCallablesInline: List[str], callableDispatcher: O
 				unpackArrays = True
 			case 'countInitialize':
 				parametersNumba = parametersNumbaDEFAULT
-		listStuffYouOughtaKnow.append(doThisStuff(callableTarget, parametersNumba, inlineCallables, unpackArrays, allImports, relativePathWrite, formatFilenameWrite))
+		FunctionDefTarget, allImports = getFunctionDef(algorithmSource, callableTarget, parametersNumba, inlineCallables, unpackArrays, allImports)
+		listFunctionDefs.append(FunctionDefTarget)
+		allImportsModule.update(allImports)
+
+	listAstImports = allImportsModule.makeListAst()
+	pythonSource = makePythonSource(listFunctionDefs, listAstImports, additional_imports)
+
+	filenameWrite = filenameModuleWrite or Z0Z_filenameModuleWrite
+
+	listStuff = writePythonAsModule(pythonSource, listCallablesInline, relativePathWrite, filenameWrite, formatFilenameWrite)
+	listStuffYouOughtaKnow.extend(listStuff)
 
 	if callableDispatcher:
 		callableTarget 	= getAlgorithmDispatcher().__name__
@@ -56,22 +106,24 @@ def makeFlowNumbaOptimized(listCallablesInline: List[str], callableDispatcher: O
 		inlineCallables	= False
 		unpackArrays	= False
 		allImports 		= UniversalImportTracker()
+		filenameWrite 	= None
 		for stuff in listStuffYouOughtaKnow:
 			statement = stuff.astForCompetentProgrammers
 			if isinstance(statement, (ast.Import, ast.ImportFrom)):
 				allImports.addAst(statement)
+		FunctionDefTarget, allImports = getFunctionDef(algorithmSource, callableTarget, parametersNumba, inlineCallables, unpackArrays, allImports)
+		listAstImports = allImports.makeListAst()
+
+		pythonSource = makePythonSource([FunctionDefTarget], listAstImports, additional_imports)
 
-		listStuffYouOughtaKnow.append(doThisStuff(callableTarget, parametersNumba, inlineCallables, unpackArrays, allImports, relativePathWrite, formatFilenameWrite))
+		listStuff = writePythonAsModule(pythonSource, [callableTarget], relativePathWrite, filenameWrite, formatFilenameWrite)
+		listStuffYouOughtaKnow.extend(listStuff)
 
 	return listStuffYouOughtaKnow
 
 if __name__ == '__main__':
-	setDatatypeModule('numpy', sourGrapes=True)
-	setDatatypeFoldsTotal('int64', sourGrapes=True)
-	setDatatypeElephino('uint8', sourGrapes=True)
-	setDatatypeLeavesTotal('uint8', sourGrapes=True)
-	Z0Z_setDatatypeModuleScalar('numba')
-	Z0Z_setDecoratorCallable('jit')
+	# Z0Z_setDatatypeModuleScalar('numba')
+	# Z0Z_setDecoratorCallable('jit')
 	listCallablesInline: List[str] = ['countInitialize', 'countParallel', 'countSequential']
 	callableDispatcher = True
 	makeFlowNumbaOptimized(listCallablesInline, callableDispatcher)