mapFolding 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

mapFolding/someAssemblyRequired/synthesizeNumba.py

@@ -2,17 +2,18 @@
 TODO: consolidate the logic in this module."""
 from mapFolding.someAssemblyRequired.synthesizeNumbaGeneralized import *
 
-def insertArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arrayTarget: numpy.ndarray, allImports: UniversalImportTracker, unrollSlices: Optional[int]=None) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+def insertArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arrayTarget: numpy.ndarray, allImports: UniversalImportTracker, unrollSlices: int | None = None) -> tuple[ast.FunctionDef, UniversalImportTracker]:
 	arrayType = type(arrayTarget)
 	moduleConstructor = arrayType.__module__
 	constructorName = arrayType.__name__
 	# 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]:
+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:
@@ -91,7 +87,7 @@ def removeAssignTargetFrom_body(FunctionDefTarget: ast.FunctionDef, identifier:
 			return False
 		targetNode = astNode.targets[0]
 		return (isinstance(targetNode, ast.Subscript) and isinstance(targetNode.value, ast.Name) and targetNode.value.id == identifier) or ifThis.nameIs(identifier)(targetNode)
-	def replacementBuilder(astNode: ast.AST) -> Optional[ast.stmt]:
+	def replacementBuilder(astNode: ast.AST) -> ast.stmt | None:
 		# Returning None removes the node.
 		return None
 	FunctionDefSherpa = NodeReplacer(predicate, replacementBuilder).visit(FunctionDefTarget)
@@ -102,7 +98,7 @@ def removeAssignTargetFrom_body(FunctionDefTarget: ast.FunctionDef, identifier:
 	ast.fix_missing_locations(FunctionDefTarget)
 	return FunctionDefTarget
 
-def findAndReplaceAnnAssignIn_body(FunctionDefTarget: ast.FunctionDef, allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+def findAndReplaceAnnAssignIn_body(FunctionDefTarget: ast.FunctionDef, allImports: UniversalImportTracker) -> tuple[ast.FunctionDef, UniversalImportTracker]:
 	moduleConstructor = Z0Z_getDatatypeModuleScalar()
 	for stmt in FunctionDefTarget.body.copy():
 		if isinstance(stmt, ast.AnnAssign):
@@ -136,15 +132,12 @@ 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]:
+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."""
 	# Create AST for multiplication operation
 	multiplicand = Z0Z_identifierCountFolds
@@ -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)
 
@@ -162,7 +157,7 @@ def insertReturnStatementIn_body(FunctionDefTarget: ast.FunctionDef, arrayTarget
 
 	return FunctionDefTarget, allImports
 
-def findAndReplaceWhileLoopIn_body(FunctionDefTarget: ast.FunctionDef, iteratorName: str, iterationsTotal: int) -> Any:
+def findAndReplaceWhileLoopIn_body(FunctionDefTarget: ast.FunctionDef, iteratorName: str, iterationsTotal: int) -> ast.FunctionDef:
 	"""
 	Unroll all nested while loops matching the condition that their test uses `iteratorName`.
 	"""
@@ -185,11 +180,11 @@ def findAndReplaceWhileLoopIn_body(FunctionDefTarget: ast.FunctionDef, iteratorN
 			self.iteratorName = iteratorName
 			self.iterationsTotal = iterationsTotal
 
-		def visit_While(self, node: ast.While) -> List[ast.stmt]:
+		def visit_While(self, node: ast.While) -> list[ast.stmt]:
 				# Check if the while loop's test uses the iterator.
 			if isinstance(node.test, ast.Compare) and ifThis.nameIs(self.iteratorName)(node.test.left):
 				# Recurse the while loop body and remove AugAssign that increments the iterator.
-				cleanBodyStatements: List[ast.stmt] = []
+				cleanBodyStatements: list[ast.stmt] = []
 				for loopStatement in node.body:
 					# Recursively visit nested statements.
 					visitedStatement = self.visit(loopStatement)
@@ -203,7 +198,7 @@ def findAndReplaceWhileLoopIn_body(FunctionDefTarget: ast.FunctionDef, iteratorN
 						continue
 					cleanBodyStatements.append(visitedStatement)
 
-				newStatements: List[ast.stmt] = []
+				newStatements: list[ast.stmt] = []
 				# Unroll using the filtered body.
 				for iterationIndex in range(self.iterationsTotal):
 					for loopStatement in cleanBodyStatements:
@@ -227,7 +222,7 @@ def findAndReplaceWhileLoopIn_body(FunctionDefTarget: ast.FunctionDef, iteratorN
 	ast.fix_missing_locations(newFunctionDef)
 	return newFunctionDef
 
-def makeLauncherBasicJobNumba(callableTarget: str, pathFilenameFoldsTotal: pathlib.Path) -> ast.Module:
+def makeLauncherBasicJobNumba(callableTarget: str, pathFilenameFoldsTotal: Path) -> ast.Module:
 	linesLaunch = f"""
 if __name__ == '__main__':
 	import time
@@ -240,9 +235,12 @@ 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: ParametersNumba | None = None,
+					inlineCallables: bool | None = False,
+					unpackArrays: bool | None = False,
+					allImports: UniversalImportTracker | None = None) -> tuple[ast.FunctionDef, UniversalImportTracker]:
 	if allImports is None:
 		allImports = UniversalImportTracker()
 	for statement in astModule.body:
@@ -253,6 +251,7 @@ def makeAstModuleForOneCallable(pythonSource: str, callableTarget: str, paramete
 		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)
@@ -270,11 +269,9 @@ 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 decorateCallableWithNumba(FunctionDefTarget: ast.FunctionDef, allImports: UniversalImportTracker, parametersNumba: ParametersNumba | None = None) -> tuple[ast.FunctionDef, UniversalImportTracker]:
 	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():
@@ -311,7 +308,7 @@ def decorateCallableWithNumba(FunctionDefTarget: ast.FunctionDef, allImports: Un
 	datatypeModuleDecorator = Z0Z_getDatatypeModuleScalar()
 	list_argsDecorator: Sequence[ast.expr] = []
 
-	list_arg4signature_or_function: List[ast.expr] = []
+	list_arg4signature_or_function: list[ast.expr] = []
 	for parameter in FunctionDefTarget.args.args:
 		signatureElement = make_arg4parameter(parameter)
 		if signatureElement:

mapFolding/someAssemblyRequired/synthesizeNumbaGeneralized.py

@@ -1,7 +1,7 @@
 from mapFolding import (
 	computationState,
 	EnumIndices,
-	formatModuleNameDEFAULT,
+	formatFilenameModuleDEFAULT,
 	FREAKOUT,
 	getAlgorithmDispatcher,
 	getAlgorithmSource,
@@ -35,8 +35,9 @@ from mapFolding.someAssemblyRequired.makeJob import makeStateJob
 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 collections.abc import Callable, Sequence
+from typing import Any, cast
+from Z0Z_tools import autoDecodingRLE, updateExtendPolishDictionaryLists
 import ast
 import autoflake
 import collections
@@ -46,12 +47,44 @@ import inspect
 import more_itertools
 import numba
 import numpy
-import os
-import pathlib
+from os import PathLike
+from pathlib import Path
 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], ast.stmt | None]) -> 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,23 +104,40 @@ 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
-	def copy_astCallKeywords(astCall: ast.Call) -> Dict[str, Any]:
+	def copy_astCallKeywords(astCall: ast.Call) -> dict[str, Any]:
 		"""Extract keyword parameters from a decorator AST node."""
-		dictionaryKeywords: Dict[str, Any] = {}
+		dictionaryKeywords: dict[str, Any] = {}
 		for keywordItem in astCall.keywords:
 			if isinstance(keywordItem.value, ast.Constant) and keywordItem.arg is not None:
 				dictionaryKeywords[keywordItem.arg] = keywordItem.value.value
 		return dictionaryKeywords
 
 	@staticmethod
-	def make_astCall(name: str, args: Optional[Sequence[ast.expr]]=None, list_astKeywords: Optional[Sequence[ast.keyword]]=None, dictionaryKeywords: Optional[Dict[str, Any]]=None) -> ast.Call:
+	def make_astCall(name: str, args: Sequence[ast.expr] | None = None, list_astKeywords: Sequence[ast.keyword] | None = None, dictionaryKeywords: dict[str, Any] | None = None) -> ast.Call:
 		list_dictionaryKeywords = [ast.keyword(arg=keyName, value=ast.Constant(value=keyValue)) for keyName, keyValue in dictionaryKeywords.items()] if dictionaryKeywords else []
 		return ast.Call(
 			func=ast.Name(id=name, ctx=ast.Load()),
@@ -103,15 +153,14 @@ 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]:
 			Visits each node in the AST, replacing or removing it based on the predicate.
 	"""
-	def __init__(self, findMe: Callable[[ast.AST], bool], nodeReplacementBuilder: Callable[[ast.AST], Optional[ast.AST]]) -> None:
+	def __init__(self, findMe: Callable[[ast.AST], bool], nodeReplacementBuilder: Callable[[ast.AST], ast.AST | None]) -> None:
 		self.findMe = findMe
 		self.nodeReplacementBuilder = nodeReplacementBuilder
 
@@ -133,28 +182,51 @@ def thisIsAnyNumbaJitDecorator(Ima: ast.AST) -> bool:
 # Domain-based
 class UniversalImportTracker:
 	def __init__(self) -> None:
-		self.dictionaryImportFrom: Dict[str, Set] = collections.defaultdict(set)
+		self.dictionaryImportFrom: dict[str, set] = collections.defaultdict(set)
 		self.setImport = set()
 
-	def addAst(self, astImport_: Union[ast.Import, ast.ImportFrom]) -> None:
+	def addAst(self, astImport_: ast.Import | ast.ImportFrom) -> None:
 		if isinstance(astImport_, ast.Import):
 			for alias in astImport_.names:
 				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 addImportStr(self, module: str) -> None:
+		self.setImport.add(module)
 
-	def addImportFromStr(self, module: str, name: str) -> None:
-		self.dictionaryImportFrom[module].add(name)
+	def addImportFromStr(self, module: str, name: str, asname: str | None = None) -> None:
+		self.dictionaryImportFrom[module].add((name, asname))
 
-	def addImportStr(self, name: str) -> None:
-		self.setImport.add(name)
+	def makeListAst(self) -> list[ast.ImportFrom | ast.Import]:
+		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))
 
-	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]
+		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):
 	"""
@@ -182,11 +254,11 @@ class RecursiveInliner(ast.NodeTransformer):
 				dictionaryFunctions, its statements are expanded in place, effectively inlining
 				the called function's statements into the surrounding context.
 	"""
-	def __init__(self, dictionaryFunctions: Dict[str, ast.FunctionDef]):
+	def __init__(self, dictionaryFunctions: dict[str, ast.FunctionDef]):
 		self.dictionaryFunctions = dictionaryFunctions
-		self.callablesCompleted: Set[str] = set()
+		self.callablesCompleted: set[str] = set()
 
-	def inlineFunctionBody(self, callableTargetName: str) -> Optional[ast.FunctionDef]:
+	def inlineFunctionBody(self, callableTargetName: str) -> ast.FunctionDef | None:
 		if (callableTargetName in self.callablesCompleted):
 			return None
 
@@ -209,7 +281,7 @@ class RecursiveInliner(ast.NodeTransformer):
 				return ast.Constant(value=None)
 		return callNodeVisited
 
-	def visit_Expr(self, node: ast.Expr) -> Union[ast.AST, List[ast.AST]]:
+	def visit_Expr(self, node: ast.Expr) -> ast.AST | list[ast.AST]:
 		if (isinstance(node.value, ast.Call)):
 			if (isinstance(node.value.func, ast.Name) and node.value.func.id in self.dictionaryFunctions):
 				inlineDefinition = self.inlineFunctionBody(node.value.func.id)
@@ -242,12 +314,12 @@ class UnpackArrays(ast.NodeTransformer):
 	3. Replaces original array access with the local variable
 	"""
 
-	def __init__(self, enumIndexClass: Type[EnumIndices], arrayName: str) -> None:
+	def __init__(self, enumIndexClass: type[EnumIndices], arrayName: str) -> None:
 		self.enumIndexClass = enumIndexClass
 		self.arrayName = arrayName
-		self.substitutions: Dict[str, Any] = {}
+		self.substitutions: dict[str, Any] = {}
 
-	def extract_member_name(self, node: ast.AST) -> Optional[str]:
+	def extract_member_name(self, node: ast.AST) -> str | None:
 		"""Recursively extract enum member name from any node in the AST."""
 		if isinstance(node, ast.Attribute) and node.attr == 'value':
 			innerAttribute = node.value
@@ -266,7 +338,7 @@ class UnpackArrays(ast.NodeTransformer):
 					return ast.Name(id=member_name, ctx=node.ctx)
 			elif isinstance(node, ast.Tuple):
 				# Handle tuple slices by transforming each element
-				return ast.Tuple(elts=cast(List[ast.expr], [self.transform_slice_element(elt) for elt in node.elts]), ctx=node.ctx)
+				return ast.Tuple(elts=cast(list[ast.expr], [self.transform_slice_element(elt) for elt in node.elts]), ctx=node.ctx)
 		elif isinstance(node, ast.Attribute):
 			member_name = self.extract_member_name(node)
 			if member_name:

mapFolding/someAssemblyRequired/synthesizeNumbaJob.py

@@ -1,7 +1,7 @@
 """Synthesize one file to compute `foldsTotal` of `mapShape`."""
 from mapFolding.someAssemblyRequired.synthesizeNumba import *
 
-def doUnrollCountGaps(FunctionDefTarget: ast.FunctionDef, stateJob: computationState, allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+def doUnrollCountGaps(FunctionDefTarget: ast.FunctionDef, stateJob: computationState, allImports: UniversalImportTracker) -> tuple[ast.FunctionDef, UniversalImportTracker]:
 	"""The initial results were very bad."""
 	FunctionDefTarget = findAndReplaceWhileLoopIn_body(FunctionDefTarget, 'indexDimension', stateJob['my'][indexMy.dimensionsTotal])
 	FunctionDefTarget = removeAssignTargetFrom_body(FunctionDefTarget, 'indexDimension')
@@ -27,14 +27,7 @@ def doUnrollCountGaps(FunctionDefTarget: ast.FunctionDef, stateJob: computationS
 		FunctionDefTarget = transformer.visit(FunctionDefTarget)
 	return FunctionDefTarget, allImports
 
-def writeJobNumba(mapShape: Sequence[int]
-				, algorithmSource: ModuleType
-				, callableTarget: Optional[str] = None
-				, parametersNumba: Optional[ParametersNumba] = None
-				, pathFilenameWriteJob: Optional[Union[str, os.PathLike[str]]] = None
-				, unrollCountGaps: Optional[bool] = False
-				, **keywordArguments: Optional[Any]
-				) -> pathlib.Path:
+def writeJobNumba(mapShape: Sequence[int], algorithmSource: ModuleType, callableTarget: str | None = None, parametersNumba: ParametersNumba | None = None, pathFilenameWriteJob: str | PathLike[str] | None = None, unrollCountGaps: bool | None = False, **keywordArguments: Any | None) -> Path:
 	""" Parameters: **keywordArguments: most especially for `computationDivisions` if you want to make a parallel job. Also `CPUlimit`. """
 
 	""" Notes:
@@ -64,6 +57,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 +65,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 +81,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 +107,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])
@@ -120,33 +115,19 @@ def writeJobNumba(mapShape: Sequence[int]
 
 	# NOTE add imports, make str, remove unused imports
 	astImports = allImports.makeListAst()
-	astModule = ast.Module(body=cast(List[ast.stmt], astImports + [FunctionDefTarget] + [astLauncher]), type_ignores=[])
+	astModule = ast.Module(body=cast(list[ast.stmt], astImports + [FunctionDefTarget] + [astLauncher]), type_ignores=[])
 	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:
 		filename = getFilenameFoldsTotal(stateJob['mapShape'])
 		pathRoot = getPathJobRootDEFAULT()
-		pathFilenameWriteJob = pathlib.Path(pathRoot, pathlib.Path(filename).stem, pathlib.Path(filename).with_suffix('.py'))
+		pathFilenameWriteJob = Path(pathRoot, Path(filename).stem, Path(filename).with_suffix('.py'))
 	else:
-		pathFilenameWriteJob = pathlib.Path(pathFilenameWriteJob)
+		pathFilenameWriteJob = Path(pathFilenameWriteJob)
 	pathFilenameWriteJob.parent.mkdir(parents=True, exist_ok=True)
 
 	pathFilenameWriteJob.write_text(pythonSource)
@@ -154,18 +135,19 @@ def writeJobNumba(mapShape: Sequence[int]
 	return pathFilenameWriteJob
 
 if __name__ == '__main__':
-	mapShape = [5,5]
-	from mapFolding.syntheticModules import numba_countSequential
-	algorithmSource: ModuleType = numba_countSequential
+	mapShape: list[int] = [5,5]
+	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')