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

mapFolding/someAssemblyRequired/Z0Z_workbench.py

@@ -1,34 +1,350 @@
-from mapFolding.someAssemblyRequired.synthesizeDataConverters import makeStateJob
-from mapFolding.someAssemblyRequired.synthesizeDataConverters import makeDataclassConverter
-from mapFolding.someAssemblyRequired.whatWillBe import IngredientsFunction, IngredientsModule, numbaFlow
-from mapFolding.someAssemblyRequired.synthesizeCountingFunctions import Z0Z_makeCountingFunction
+from autoflake import fix_code as autoflake_fix_code
+from mapFolding.filesystem import writeStringToHere
+from mapFolding.someAssemblyRequired import (
+	ast_Identifier,
+	extractFunctionDef,
+	ifThis,
+	IngredientsFunction,
+	IngredientsModule,
+	LedgerOfImports,
+	Make,
+	makeDictionaryReplacementStatements,
+	NodeCollector,
+	NodeReplacer,
+	RecipeSynthesizeFlow,
+	strDotStrCuzPyStoopid,
+	Then,
+)
+from mapFolding.someAssemblyRequired.ingredientsNumba import decorateCallableWithNumba
+from mapFolding.someAssemblyRequired.synthesizeDataConverters import shatter_dataclassesDOTdataclass
+from mapFolding.theSSOT import raiseIfNoneGitHubIssueNumber3
+from pathlib import Path
 import ast
 
+# Would `LibCST` be better than `ast` in some cases? https://github.com/hunterhogan/mapFolding/issues/7
+
+def Z0Z_alphaTest_putModuleOnDisk(ingredients: IngredientsModule, recipeFlow: RecipeSynthesizeFlow):
+	# Physical namespace
+	filenameStem: str = recipeFlow.moduleDispatcher
+	fileExtension: str = recipeFlow.fileExtension
+	pathPackage: Path = Path(recipeFlow.pathPackage)
+
+	# Physical and logical namespace
+	packageName: ast_Identifier | None = recipeFlow.packageName # module name of the package, if any
+	logicalPathINFIX: ast_Identifier | strDotStrCuzPyStoopid | None = recipeFlow.Z0Z_flowLogicalPathRoot
+
+	def _getLogicalPathParent() -> str | None:
+		listModules: list[ast_Identifier] = []
+		if packageName:
+			listModules.append(packageName)
+		if logicalPathINFIX:
+			listModules.append(logicalPathINFIX)
+		if listModules:
+			return '.'.join(listModules)
+		return None
+
+	def _getLogicalPathAbsolute() -> str:
+		listModules: list[ast_Identifier] = []
+		logicalPathParent: str | None = _getLogicalPathParent()
+		if logicalPathParent:
+			listModules.append(logicalPathParent)
+		listModules.append(filenameStem)
+		return '.'.join(listModules)
+
+	def getPathFilename():
+		pathRoot: Path = pathPackage
+		filename: str = filenameStem + fileExtension
+		if logicalPathINFIX:
+			whyIsThisStillAThing: list[str] = logicalPathINFIX.split('.')
+			pathRoot = pathRoot.joinpath(*whyIsThisStillAThing)
+		return pathRoot.joinpath(filename)
+
+	def absoluteImport() -> ast.Import:
+		return Make.astImport(_getLogicalPathAbsolute())
+
+	def absoluteImportFrom() -> ast.ImportFrom:
+		""" `from . import theModule` """
+		logicalPathParent: str = _getLogicalPathParent() or '.'
+		return Make.astImportFrom(logicalPathParent, [Make.astAlias(filenameStem)])
+
+	def writeModule() -> None:
+		astModule = ingredients.export()
+		ast.fix_missing_locations(astModule)
+		pythonSource: str = ast.unparse(astModule)
+		if not pythonSource: raise raiseIfNoneGitHubIssueNumber3
+		autoflake_additional_imports: list[str] = ingredients.imports.exportListModuleNames()
+		if packageName:
+			autoflake_additional_imports.append(packageName)
+		pythonSource = autoflake_fix_code(pythonSource, autoflake_additional_imports, expand_star_imports=False, remove_all_unused_imports=False, remove_duplicate_keys = False, remove_unused_variables = False,)
+		pathFilename = getPathFilename()
+		writeStringToHere(pythonSource, pathFilename)
+
+	writeModule()
+
+def inlineThisFunctionWithTheseValues(astFunctionDef: ast.FunctionDef, dictionaryReplacementStatements: dict[str, ast.stmt | list[ast.stmt]]) -> ast.FunctionDef:
+	class FunctionInliner(ast.NodeTransformer):
+		def __init__(self, dictionaryReplacementStatements: dict[str, ast.stmt | list[ast.stmt]]) -> None:
+			self.dictionaryReplacementStatements = dictionaryReplacementStatements
+
+		def generic_visit(self, node: ast.AST) -> ast.AST:
+			"""Visit all nodes and replace them if necessary."""
+			return super().generic_visit(node)
+
+		def visit_Expr(self, node: ast.Expr) -> ast.AST | list[ast.stmt]:
+			"""Visit Expr nodes and replace value if it's a function call in our dictionary."""
+			if ifThis.CallDoesNotCallItselfAndNameDOTidIsIn(self.dictionaryReplacementStatements)(node.value):
+				return self.dictionaryReplacementStatements[node.value.func.id] # type: ignore[attr-defined]
+			return node
+
+		def visit_Assign(self, node: ast.Assign) -> ast.AST | list[ast.stmt]:
+			"""Visit Assign nodes and replace value if it's a function call in our dictionary."""
+			if ifThis.CallDoesNotCallItselfAndNameDOTidIsIn(self.dictionaryReplacementStatements)(node.value):
+				return self.dictionaryReplacementStatements[node.value.func.id] # type: ignore[attr-defined]
+			return node
+
+		def visit_Call(self, node: ast.Call) -> ast.AST | list[ast.stmt]:
+			"""Replace call nodes with their replacement statements if they're in the dictionary."""
+			if ifThis.CallDoesNotCallItselfAndNameDOTidIsIn(self.dictionaryReplacementStatements)(node):
+				replacement = self.dictionaryReplacementStatements[node.func.id] # type: ignore[attr-defined]
+				if not isinstance(replacement, list):
+					return replacement
+			return node
+
+	import copy
+	keepGoing = True
+	ImaInlineFunction = copy.deepcopy(astFunctionDef)
+	while keepGoing:
+		ImaInlineFunction = copy.deepcopy(astFunctionDef)
+		FunctionInliner(copy.deepcopy(dictionaryReplacementStatements)).visit(ImaInlineFunction)
+		if ast.unparse(ImaInlineFunction) == ast.unparse(astFunctionDef):
+			keepGoing = False
+		else:
+			astFunctionDef = copy.deepcopy(ImaInlineFunction)
+	return ImaInlineFunction
+
+def replaceMatchingASTnodes(astTree: ast.AST, replacementMap: list[tuple[ast.AST, ast.AST]]) -> ast.AST:
+	"""Replace matching AST nodes using type-specific visitors.
+
+	Parameters:
+		astTree: The AST to transform
+		replacementMap: List of (find, replace) node pairs
+
+	Returns:
+		The transformed AST
+	"""
+	class TargetedNodeReplacer(ast.NodeTransformer):
+		def __init__(self, replacementMap: list[tuple[ast.AST, ast.AST]]) -> None:
+			# Group replacements by node type for more efficient lookups
+			self.replacementByType: dict[type[ast.AST], list[tuple[ast.AST, ast.AST]]] = {}
+			for findNode, replaceNode in replacementMap:
+				nodeType = type(findNode)
+				if nodeType not in self.replacementByType:
+					self.replacementByType[nodeType] = []
+				self.replacementByType[nodeType].append((findNode, replaceNode))
+
+		def visit(self, node: ast.AST) -> ast.AST:
+			"""Check if this node should be replaced before continuing traversal."""
+			nodeType = type(node)
+			if nodeType in self.replacementByType:
+				for findNode, replaceNode in self.replacementByType[nodeType]:
+					if self.nodesMatchStructurally(node, findNode):
+						return replaceNode
+			return super().visit(node)
+
+		def nodesMatchStructurally(self, node1: ast.AST | list, node2: ast.AST | list) -> bool:
+			"""Compare two AST nodes structurally, ignoring position information."""
+			# Different types can't be equal
+			if type(node1) != type(node2):
+				return False
+
+			if isinstance(node1, ast.AST):
+				# Compare fields that matter for structural equality
+				fields = [f for f in node1._fields
+							if f not in ('lineno', 'col_offset', 'end_lineno', 'end_col_offset', 'ctx')]
+
+				for field in fields:
+					smurf1 = getattr(node1, field, None)
+					smurf2 = getattr(node2, field, None)
+
+					if isinstance(smurf1, (ast.AST, list)) and isinstance(smurf2, (ast.AST, list)):
+						if not self.nodesMatchStructurally(smurf1, smurf2):
+							return False
+					elif smurf1 != smurf2:
+						return False
+				return True
+
+			elif isinstance(node1, list) and isinstance(node2, list):
+				if len(node1) != len(node2):
+					return False
+				return all(self.nodesMatchStructurally(x, y) for x, y in zip(node1, node2))
+
+			else:
+				# Direct comparison for non-AST objects (strings, numbers, etc.)
+				return node1 == node2
+
+	import copy
+	keepGoing = True
+	astResult = copy.deepcopy(astTree)
+
+	while keepGoing:
+		astBeforeChange = copy.deepcopy(astResult)
+		TargetedNodeReplacer(copy.deepcopy(replacementMap)).visit(astResult)
+
+		# Check if we've reached a fixed point (no more changes)
+		if ast.unparse(astResult) == ast.unparse(astBeforeChange):
+			keepGoing = False
+
+	return astResult
+
+def Z0Z_main() -> None:
+	numbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()
+	dictionaryReplacementStatements = makeDictionaryReplacementStatements(numbaFlow.source_astModule)
+	# TODO remove hardcoding
+	theCountingIdentifierHARDCODED = 'groupsOfFolds'
+	theCountingIdentifier = theCountingIdentifierHARDCODED
+
+	# TODO remember that `sequentialCallable` and `sourceSequentialCallable` are two different values.
+	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
+
+	# ===========================================================
+	sourcePython = numbaFlow.sourceDispatcherCallable
+	astFunctionDef = extractFunctionDef(sourcePython, numbaFlow.source_astModule)
+	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
+	ingredientsDispatcher = IngredientsFunction(astFunctionDef, LedgerOfImports(numbaFlow.source_astModule))
+
+	# sourceParallelCallable
+	(astName_dataclassesDOTdataclass, ledgerDataclassANDFragments, listAnnAssign4DataclassUnpack,
+		astTuple4AssignTargetsToFragments, listNameDataclassFragments4Parameters, list_ast_argAnnotated4ArgumentsSpecification,
+		astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns, astAssignDataclassRepack, list_keyword4DataclassInitialization) = shatter_dataclassesDOTdataclass(
+			numbaFlow.logicalPathModuleDataclass, numbaFlow.sourceDataclassIdentifier, numbaFlow.sourceDataclassInstanceTaskDistribution)
+	ingredientsDispatcher.imports.update(ledgerDataclassANDFragments)
+
+	# TODO remove hardcoding
+	namespaceHARDCODED = 'concurrencyManager'
+	identifierHARDCODED = 'submit'
+	namespace = namespaceHARDCODED
+	identifier = identifierHARDCODED
+	NodeReplacer(
+		findThis = ifThis.isAssignAndValueIsCallNamespace_Identifier(namespace, identifier)
+		, doThat = Then.insertThisAbove(listAnnAssign4DataclassUnpack)
+			).visit(ingredientsDispatcher.astFunctionDef)
+	NodeReplacer(
+		findThis = ifThis.isCallNamespace_Identifier(namespace, identifier)
+		, doThat = Then.replaceWith(Make.astCall(Make.astAttribute(Make.astName(namespace), identifier)
+									, listArguments=[Make.astName(numbaFlow.parallelCallable)] + listNameDataclassFragments4Parameters))
+			).visit(ingredientsDispatcher.astFunctionDef)
+
+	CapturedAssign: list[ast.AST] = []
+	CapturedCall: list[ast.Call] = []
+	findThis = ifThis.isCall
+	doThat = [Then.appendTo(CapturedCall)]
+	capture = NodeCollector(findThis, doThat)
+
+	NodeCollector(
+		findThis = ifThis.isAssignAndTargets0Is(ifThis.isSubscript_Identifier(numbaFlow.sourceDataclassInstance))
+		, doThat = [Then.appendTo(CapturedAssign)
+					, lambda node: capture.visit(node)]
+			).visit(ingredientsDispatcher.astFunctionDef)
+
+	newAssign = CapturedAssign[0]
+	NodeReplacer(
+		findThis = lambda node: ifThis.isSubscript(node) and ifThis.isAttribute(node.value) and ifThis.isCall(node.value.value)
+		, doThat = Then.replaceWith(CapturedCall[0])
+			).visit(newAssign)
+
+	NodeReplacer(
+		findThis = ifThis.isAssignAndTargets0Is(ifThis.isSubscript_Identifier(numbaFlow.sourceDataclassInstance))
+		, doThat = Then.replaceWith(newAssign)
+			).visit(ingredientsDispatcher.astFunctionDef)
+
+	# sourceSequentialCallable
+	(astName_dataclassesDOTdataclass, ledgerDataclassANDFragments, listAnnAssign4DataclassUnpack,
+		astTuple4AssignTargetsToFragments, listNameDataclassFragments4Parameters, list_ast_argAnnotated4ArgumentsSpecification,
+		astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns, astAssignDataclassRepack, list_keyword4DataclassInitialization) = shatter_dataclassesDOTdataclass(
+			numbaFlow.logicalPathModuleDataclass, numbaFlow.sourceDataclassIdentifier, numbaFlow.sourceDataclassInstance)
+	ingredientsDispatcher.imports.update(ledgerDataclassANDFragments)
+
+	NodeReplacer(
+		findThis = ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.sourceSequentialCallable)
+		, doThat = Then.insertThisAbove(listAnnAssign4DataclassUnpack)
+			).visit(ingredientsDispatcher.astFunctionDef)
+	NodeReplacer(
+		findThis = ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.sourceSequentialCallable)
+		# findThis = ifThis.isReturn
+		, doThat = Then.insertThisBelow([astAssignDataclassRepack])
+			).visit(ingredientsDispatcher.astFunctionDef)
+	# TODO reconsider: This calls a function, but I don't inspect the function for its parameters or return.
+	NodeReplacer(
+		findThis = ifThis.isAssignAndValueIsCall_Identifier(numbaFlow.sourceSequentialCallable)
+		, doThat = Then.replaceWith(Make.astAssign(listTargets=[astTuple4AssignTargetsToFragments], value=Make.astCall(Make.astName(numbaFlow.sequentialCallable), listNameDataclassFragments4Parameters)))
+			).visit(ingredientsDispatcher.astFunctionDef)
+
+	# ===========================================================
+	sourcePython = numbaFlow.sourceInitializeCallable
+	astFunctionDef = extractFunctionDef(sourcePython, numbaFlow.source_astModule)
+	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
+	astFunctionDef = inlineThisFunctionWithTheseValues(astFunctionDef, dictionaryReplacementStatements)
+	ingredientsInitialize = IngredientsFunction(astFunctionDef, LedgerOfImports(numbaFlow.source_astModule))
+
+	# ===========================================================
+	sourcePython = numbaFlow.sourceParallelCallable
+	astFunctionDef = extractFunctionDef(sourcePython, numbaFlow.source_astModule)
+	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
+	astFunctionDef = inlineThisFunctionWithTheseValues(astFunctionDef, dictionaryReplacementStatements)
+	ingredientsParallel = IngredientsFunction(astFunctionDef, LedgerOfImports(numbaFlow.source_astModule))
+	ingredientsParallel.astFunctionDef.name = numbaFlow.parallelCallable
+	ingredientsParallel.astFunctionDef.args = Make.astArgumentsSpecification(args=list_ast_argAnnotated4ArgumentsSpecification)
+	NodeReplacer(
+		findThis = ifThis.isReturn
+		, doThat = Then.replaceWith(Make.astReturn(astTuple4AssignTargetsToFragments))
+			).visit(ingredientsParallel.astFunctionDef)
+	NodeReplacer(
+		findThis = ifThis.isReturn
+		# , doThat = Then.replaceWith(Make.astReturn(astTuple4AssignTargetsToFragments))
+		, doThat = Then.replaceWith(Make.astReturn(Make.astName(theCountingIdentifier)))
+			).visit(ingredientsParallel.astFunctionDef)
+	theCountingIdentifierAnnotation = next(
+		ast_arg.annotation for ast_arg in list_ast_argAnnotated4ArgumentsSpecification if ast_arg.arg == theCountingIdentifier)
+	ingredientsParallel.astFunctionDef.returns = theCountingIdentifierAnnotation
+	# ingredientsParallel.astFunctionDef.returns = astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns
+	replacementMap = [(statement.value, statement.target) for statement in listAnnAssign4DataclassUnpack]
+	ingredientsParallel.astFunctionDef = replaceMatchingASTnodes(
+		ingredientsParallel.astFunctionDef, replacementMap) # type: ignore
+	# TODO a tool to automatically remove unused variables from the ArgumentsSpecification (return, and returns) _might_ be nice.
+	# But, I would need to update the calling function, too.
+	ingredientsParallel = decorateCallableWithNumba(ingredientsParallel) # parametersNumbaParallelDEFAULT
+
+	# ===========================================================
+	sourcePython = numbaFlow.sourceSequentialCallable
+	astFunctionDef = extractFunctionDef(sourcePython, numbaFlow.source_astModule)
+	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
+	astFunctionDef = inlineThisFunctionWithTheseValues(astFunctionDef, dictionaryReplacementStatements)
+	ingredientsSequential = IngredientsFunction(astFunctionDef, LedgerOfImports(numbaFlow.source_astModule))
+	ingredientsSequential.astFunctionDef.name = numbaFlow.sequentialCallable
+	ingredientsSequential.astFunctionDef.args = Make.astArgumentsSpecification(args=list_ast_argAnnotated4ArgumentsSpecification)
+	NodeReplacer(
+		findThis = ifThis.isReturn
+		, doThat = Then.replaceWith(Make.astReturn(astTuple4AssignTargetsToFragments))
+			).visit(ingredientsSequential.astFunctionDef)
+	NodeReplacer(
+		findThis = ifThis.isReturn
+		, doThat = Then.replaceWith(Make.astReturn(astTuple4AssignTargetsToFragments))
+			).visit(ingredientsSequential.astFunctionDef)
+	ingredientsSequential.astFunctionDef.returns = astSubscriptPrimitiveTupleAnnotations4FunctionDef_returns
+	replacementMap = [(statement.value, statement.target) for statement in listAnnAssign4DataclassUnpack]
+	ingredientsSequential.astFunctionDef = replaceMatchingASTnodes(
+		ingredientsSequential.astFunctionDef, replacementMap) # type: ignore
+	# TODO a tool to automatically remove unused variables from the ArgumentsSpecification (return, and returns) _might_ be nice.
+	# But, I would need to update the calling function, too.
+	ingredientsSequential = decorateCallableWithNumba(ingredientsSequential)
+
+	ingredientsModuleNumbaUnified = IngredientsModule(
+		ingredientsFunction=[ingredientsInitialize,
+							ingredientsParallel,
+							ingredientsSequential,
+							ingredientsDispatcher], imports=LedgerOfImports(numbaFlow.source_astModule))
+
+	Z0Z_alphaTest_putModuleOnDisk(ingredientsModuleNumbaUnified, numbaFlow)
+
 if __name__ == '__main__':
-	ingredientsFunctionDataConverter = makeDataclassConverter(
-		dataclassIdentifierAsStr=numbaFlow.dataclassIdentifierAsStr
-		, logicalPathModuleDataclass=numbaFlow.logicalPathModuleDataclass
-		, dataclassInstanceAsStr=numbaFlow.dataclassInstanceAsStr
-
-		, dispatcherCallableAsStr=numbaFlow.dispatcherCallableAsStr
-		, logicalPathModuleDispatcher=numbaFlow.logicalPathModuleDispatcher
-		, dataConverterCallableAsStr=numbaFlow.dataConverterCallableAsStr
-		)
-
-	# initialize with theDao
-	dataInitializationHack = "state=makeStateJob(state.mapShape,writeJob=False)"
-	ingredientsFunctionDataConverter.FunctionDef.body.insert(0, ast.parse(dataInitializationHack).body[0])
-	ingredientsFunctionDataConverter.imports.addImportFromStr('mapFolding.someAssemblyRequired', 'makeStateJob')
-
-	ingredientsSequential = Z0Z_makeCountingFunction(numbaFlow.sequentialCallableAsStr
-													, numbaFlow.sourceAlgorithm
-													, inline=True
-													, dataclass=False)
-
-	ingredientsModuleDataConverter = IngredientsModule(
-		name=numbaFlow.dataConverterModule,
-		ingredientsFunction=ingredientsFunctionDataConverter,
-		logicalPathINFIX=numbaFlow.moduleOfSyntheticModules,
-	)
-
-	ingredientsModuleDataConverter.writeModule()
+	Z0Z_main()

mapFolding/someAssemblyRequired/__init__.py

@@ -1,16 +1,17 @@
-from mapFolding.someAssemblyRequired.whatWillBe import (
+from mapFolding.someAssemblyRequired.transformationTools import (
 	ast_Identifier as ast_Identifier,
 	extractClassDef as extractClassDef,
 	extractFunctionDef as extractFunctionDef,
-	executeActionUnlessDescendantMatches as executeActionUnlessDescendantMatches,
 	ifThis as ifThis,
 	IngredientsFunction as IngredientsFunction,
 	IngredientsModule as IngredientsModule,
 	LedgerOfImports as LedgerOfImports,
-	listNumbaCallableDispatchees as listNumbaCallableDispatchees,
 	Make as Make,
+	makeDictionaryReplacementStatements as makeDictionaryReplacementStatements,
 	NodeCollector as NodeCollector,
 	NodeReplacer as NodeReplacer,
+	RecipeSynthesizeFlow as RecipeSynthesizeFlow,
 	strDotStrCuzPyStoopid as strDotStrCuzPyStoopid,
 	Then as Then,
+	Z0Z_executeActionUnlessDescendantMatches as Z0Z_executeActionUnlessDescendantMatches,
 	)

mapFolding/someAssemblyRequired/getLLVMforNoReason.py

@@ -1,4 +1,3 @@
-import importlib
 from importlib.machinery import ModuleSpec
 from types import ModuleType
 import importlib.util

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(dataclassIdentifierAsStr: str,
-		logicalPathModuleDataclass: str,
-		dataclassInstanceAsStr: str,
-		dispatcherCallableAsStr: str,
-		logicalPathModuleDispatcher: str,
-		dataConverterCallableAsStr: str,
-		) -> IngredientsFunction:
-
-	astNameDataclass, ledgerDataclassAndFragments, list_astAnnAssign, list_astNameDataclassFragments, list_astKeywordDataclassFragments, astTupleForAssignTargetsToFragments = shatter_dataclassesDOTdataclass(logicalPathModuleDataclass, dataclassIdentifierAsStr, dataclassInstanceAsStr)
-
-	ingredientsFunction = IngredientsFunction(
-		FunctionDef = Make.astFunctionDef(name=dataConverterCallableAsStr
-										, argumentsSpecification=Make.astArgumentsSpecification(args=[Make.astArg(dataclassInstanceAsStr, astNameDataclass)])
-										, body = cast(list[ast.stmt], list_astAnnAssign)
-										, returns = astNameDataclass
-										)
-		, imports = ledgerDataclassAndFragments
-	)
-
-	callToDispatcher = Make.astAssign(listTargets=[astTupleForAssignTargetsToFragments]
-										, value=Make.astCall(Make.astName(dispatcherCallableAsStr), args=list_astNameDataclassFragments))
-	ingredientsFunction.FunctionDef.body.append(callToDispatcher)
-	ingredientsFunction.imports.addImportFromStr(logicalPathModuleDispatcher, dispatcherCallableAsStr)
+	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