mapFolding 0.11.2__py3-none-any.whl → 0.11.4__py3-none-any.whl

mapFolding/someAssemblyRequired/_toolkitContainers.py

@@ -18,138 +18,18 @@ The containers work in conjunction with transformation tools that manipulate the
 specific optimizations and transformations.
 """
 
+from astToolkit import ClassIsAndAttribute, DOT, LedgerOfImports, Make, NodeTourist, str_nameDOTname, Then
 from collections.abc import Callable
-from astToolkit import ClassIsAndAttribute
 from copy import deepcopy
-from mapFolding.someAssemblyRequired import ast_Identifier, DOT, IfThis, Make, NodeTourist, parseLogicalPath2astModule, str_nameDOTname, Then, LedgerOfImports
-from mapFolding import raiseIfNoneGitHubIssueNumber3, The
-from pathlib import Path, PurePosixPath
+from mapFolding.someAssemblyRequired import IfThis, raiseIfNoneGitHubIssueNumber3
 from typing import Any, cast
 import ast
 import dataclasses
 
-# Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
-@dataclasses.dataclass
-class RecipeSynthesizeFlow:
-	"""
-	Configure the generation of new modules, including Numba-accelerated code modules.
-
-	RecipeSynthesizeFlow defines the complete blueprint for transforming an original Python algorithm into an optimized,
-	accelerated implementation. It specifies:
-
-	1. Source code locations and identifiers.
-	2. Target code locations and identifiers.
-	3. Naming conventions for generated modules and functions.
-	4. File system paths for output files.
-	5. Import relationships between components.
-
-	This configuration class serves as a single source of truth for the code generation process, ensuring consistency
-	across all generated artifacts while enabling customization of the transformation assembly line.
-
-	The transformation process uses this configuration to extract functions from the source module, transform them
-	according to optimization rules, and output properly structured optimized modules with all necessary imports.
-	"""
-	# ========================================
-	# Source
-	source_astModule: ast.Module = parseLogicalPath2astModule(The.logicalPathModuleSourceAlgorithm)
-	"""AST of the source algorithm module containing the original implementation."""
-
-	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-	sourceCallableDispatcher: ast_Identifier = The.sourceCallableDispatcher
-	sourceCallableInitialize: ast_Identifier = The.sourceCallableInitialize
-	sourceCallableParallel: ast_Identifier = The.sourceCallableParallel
-	sourceCallableSequential: ast_Identifier = The.sourceCallableSequential
-
-	sourceDataclassIdentifier: ast_Identifier = The.dataclassIdentifier
-	sourceDataclassInstance: ast_Identifier = The.dataclassInstance
-	sourceDataclassInstanceTaskDistribution: ast_Identifier = The.dataclassInstanceTaskDistribution
-	sourceLogicalPathModuleDataclass: str_nameDOTname = The.logicalPathModuleDataclass
-
-	sourceConcurrencyManagerNamespace = The.sourceConcurrencyManagerNamespace
-	sourceConcurrencyManagerIdentifier = The.sourceConcurrencyManagerIdentifier
-
-	# ========================================
-	# Logical identifiers (as opposed to physical identifiers)
-	# ========================================
-	# Package ================================
-	packageIdentifier: ast_Identifier | None = The.packageName
-
-	# Qualified logical path ================================
-	logicalPathModuleDataclass: str_nameDOTname = sourceLogicalPathModuleDataclass
-	logicalPathFlowRoot: ast_Identifier | None = 'syntheticModules'
-	""" `logicalPathFlowRoot` likely corresponds to a physical filesystem directory."""
-
-	# Module ================================
-	moduleDispatcher: ast_Identifier = 'numbaCount'
-	moduleInitialize: ast_Identifier = moduleDispatcher
-	moduleParallel: ast_Identifier = moduleDispatcher
-	moduleSequential: ast_Identifier = moduleDispatcher
-
-	# Function ================================
-	callableDispatcher: ast_Identifier = sourceCallableDispatcher
-	callableInitialize: ast_Identifier = sourceCallableInitialize
-	callableParallel: ast_Identifier = sourceCallableParallel
-	callableSequential: ast_Identifier = sourceCallableSequential
-	concurrencyManagerNamespace: ast_Identifier = sourceConcurrencyManagerNamespace
-	concurrencyManagerIdentifier: ast_Identifier = sourceConcurrencyManagerIdentifier
-	dataclassIdentifier: ast_Identifier = sourceDataclassIdentifier
-
-	# Variable ================================
-	dataclassInstance: ast_Identifier = sourceDataclassInstance
-	dataclassInstanceTaskDistribution: ast_Identifier = sourceDataclassInstanceTaskDistribution
-
-	removeDataclassDispatcher: bool = False
-	removeDataclassInitialize: bool = False
-	removeDataclassParallel: bool = True
-	removeDataclassSequential: bool = True
-	# ========================================
-	# Computed
-	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-	# theFormatStrModuleSynthetic = "{packageFlow}Count"
-	# theFormatStrModuleForCallableSynthetic = theFormatStrModuleSynthetic + "_{callableTarget}"
-	# theModuleDispatcherSynthetic: ast_Identifier = theFormatStrModuleForCallableSynthetic.format(packageFlow=packageFlowSynthetic, callableTarget=The.sourceCallableDispatcher)
-	# theLogicalPathModuleDispatcherSynthetic: str = '.'.join([The.packageName, The.moduleOfSyntheticModules, theModuleDispatcherSynthetic])
-	# logicalPathModuleDispatcher: str = '.'.join([Z0Z_flowLogicalPathRoot, moduleDispatcher])
-
-	# ========================================
-	# Filesystem (names of physical objects)
-	pathPackage: PurePosixPath | None = PurePosixPath(The.pathPackage)
-	fileExtension: str = The.fileExtension
-
-	def _makePathFilename(self, filenameStem: str,
-			pathRoot: PurePosixPath | None = None,
-			logicalPathINFIX: str_nameDOTname | None = None,
-			fileExtension: str | None = None,
-			) -> PurePosixPath:
-		"""filenameStem: (hint: the name of the logical module)"""
-		if pathRoot is None:
-			pathRoot = self.pathPackage or PurePosixPath(Path.cwd())
-		if logicalPathINFIX:
-			whyIsThisStillAThing: list[str] = logicalPathINFIX.split('.')
-			pathRoot = pathRoot.joinpath(*whyIsThisStillAThing)
-		if fileExtension is None:
-			fileExtension = self.fileExtension
-		filename: str = filenameStem + fileExtension
-		return pathRoot.joinpath(filename)
-
-	@property
-	def pathFilenameDispatcher(self) -> PurePosixPath:
-		return self._makePathFilename(filenameStem=self.moduleDispatcher, logicalPathINFIX=self.logicalPathFlowRoot)
-	@property
-	def pathFilenameInitialize(self) -> PurePosixPath:
-		return self._makePathFilename(filenameStem=self.moduleInitialize, logicalPathINFIX=self.logicalPathFlowRoot)
-	@property
-	def pathFilenameParallel(self) -> PurePosixPath:
-		return self._makePathFilename(filenameStem=self.moduleParallel, logicalPathINFIX=self.logicalPathFlowRoot)
-	@property
-	def pathFilenameSequential(self) -> PurePosixPath:
-		return self._makePathFilename(filenameStem=self.moduleSequential, logicalPathINFIX=self.logicalPathFlowRoot)
-
 dummyAssign = Make.Assign([Make.Name("dummyTarget")], Make.Constant(None))
 dummySubscript = Make.Subscript(Make.Name("dummy"), Make.Name("slice"))
 dummyTuple = Make.Tuple([Make.Name("dummyElement")])
 
-# Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
 @dataclasses.dataclass
 class ShatteredDataclass:
 	countingVariableAnnotation: ast.expr
@@ -158,10 +38,10 @@ class ShatteredDataclass:
 	countingVariableName: ast.Name
 	"""AST name node representing the counting variable identifier."""
 
-	field2AnnAssign: dict[ast_Identifier, ast.AnnAssign | ast.Assign] = dataclasses.field(default_factory=lambda: dict[ast_Identifier, ast.AnnAssign | ast.Assign]())
+	field2AnnAssign: dict[str, ast.AnnAssign | ast.Assign] = dataclasses.field(default_factory=lambda: dict[str, ast.AnnAssign | ast.Assign]())
 	"""Maps field names to their corresponding AST call expressions."""
 
-	Z0Z_field2AnnAssign: dict[ast_Identifier, tuple[ast.AnnAssign | ast.Assign, str]] = dataclasses.field(default_factory=lambda: dict[ast_Identifier, tuple[ast.AnnAssign | ast.Assign, str]]())
+	Z0Z_field2AnnAssign: dict[str, tuple[ast.AnnAssign | ast.Assign, str]] = dataclasses.field(default_factory=lambda: dict[str, tuple[ast.AnnAssign | ast.Assign, str]]())
 
 	fragments4AssignmentOrParameters: ast.Tuple = dummyTuple
 	"""AST tuple used as target for assignment to capture returned fragments."""
@@ -213,12 +93,12 @@ class DeReConstructField2ast:
 	"""
 	dataclassesDOTdataclassLogicalPathModule: dataclasses.InitVar[str_nameDOTname]
 	dataclassClassDef: dataclasses.InitVar[ast.ClassDef]
-	dataclassesDOTdataclassInstance_Identifier: dataclasses.InitVar[ast_Identifier]
+	dataclassesDOTdataclassInstance_Identifier: dataclasses.InitVar[str]
 	field: dataclasses.InitVar[dataclasses.Field[Any]]
 
 	ledger: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
 
-	name: ast_Identifier = dataclasses.field(init=False)
+	name: str = dataclasses.field(init=False)
 	typeBuffalo: type[Any] | str | Any = dataclasses.field(init=False)
 	default: Any | None = dataclasses.field(init=False)
 	default_factory: Callable[..., Any] | None = dataclasses.field(init=False)
@@ -237,7 +117,7 @@ class DeReConstructField2ast:
 	astAnnAssignConstructor: ast.AnnAssign|ast.Assign = dataclasses.field(init=False)
 	Z0Z_hack: tuple[ast.AnnAssign|ast.Assign, str] = dataclasses.field(init=False)
 
-	def __post_init__(self, dataclassesDOTdataclassLogicalPathModule: str_nameDOTname, dataclassClassDef: ast.ClassDef, dataclassesDOTdataclassInstance_Identifier: ast_Identifier, field: dataclasses.Field[Any]) -> None:
+	def __post_init__(self, dataclassesDOTdataclassLogicalPathModule: str_nameDOTname, dataclassClassDef: ast.ClassDef, dataclassesDOTdataclassInstance_Identifier: str, field: dataclasses.Field[Any]) -> None:
 		self.compare = field.compare
 		self.default = field.default if field.default is not dataclasses.MISSING else None
 		self.default_factory = field.default_factory if field.default_factory is not dataclasses.MISSING else None
@@ -276,7 +156,7 @@ class DeReConstructField2ast:
 			ast_expr = Make.Subscript(Make.Name(annotationType), Make.Tuple([axesSubscript, Make.Subscript(Make.Name('dtype'), dtype_asnameName)]))
 			constructor = 'array'
 			self.ledger.addImportFrom_asStr(moduleWithLogicalPath, constructor)
-			dtypeIdentifier: ast_Identifier = dtype.__name__
+			dtypeIdentifier: str = dtype.__name__
 			self.ledger.addImportFrom_asStr(moduleWithLogicalPath, dtypeIdentifier, dtype_asnameName.id)
 			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, ast_expr, Make.Call(Make.Name(constructor), list_keyword=[Make.keyword('dtype', dtype_asnameName)]))
 			self.astAnnAssignConstructor = Make.Assign([self.astName], Make.Call(Make.Name(constructor), list_keyword=[Make.keyword('dtype', dtype_asnameName)]))
@@ -285,7 +165,7 @@ class DeReConstructField2ast:
 			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, Make.Call(self.astAnnotation, [Make.Constant(-1)]))
 			self.Z0Z_hack = (self.astAnnAssignConstructor, 'scalar')
 		elif isinstance(self.astAnnotation, ast.Subscript):
-			elementConstructor: ast_Identifier = self.metadata['elementConstructor']
+			elementConstructor: str = self.metadata['elementConstructor']
 			self.ledger.addImportFrom_asStr(dataclassesDOTdataclassLogicalPathModule, elementConstructor)
 			takeTheTuple = deepcopy(self.astAnnotation.slice)
 			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, takeTheTuple)

mapFolding/someAssemblyRequired/infoBooth.py

@@ -0,0 +1,20 @@
+from mapFolding import PackageSettings
+import dataclasses
+
+dataclassInstanceIdentifierHardcoded: str = 'state'
+sourceCallableDispatcherHARDCODED: str = 'doTheNeedful'
+
+class raiseIfNoneGitHubIssueNumber3(Exception): pass
+
+dictionaryEstimates: dict[tuple[int, ...], int] = {
+	(2,2,2,2,2,2,2,2): 798148657152000,
+	(2,21): 776374224866624,
+	(3,15): 824761667826225,
+	(3,3,3,3): 85109616000000000000000000000000,
+	(8,8): 791274195985524900,
+}
+algorithmSourceModuleHARDCODED: str = 'daoOfMapFolding'
+sourceCallableIdentifierHARDCODED: str = 'count'
+logicalPathInfixHARDCODED: str = 'syntheticModules'
+theCountingIdentifierHARDCODED: str = 'groupsOfFolds'
+dataPackingModuleIdentifierHARDCODED: str = 'dataPacking'

mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py

@@ -1,10 +1,9 @@
-from astToolkit import ClassIsAndAttribute
-from mapFolding import getPathFilenameFoldsTotal, raiseIfNoneGitHubIssueNumber3, The, MapFoldingState
-from mapFolding.someAssemblyRequired import (
-	ast_Identifier,
+from mapFolding import getPathFilenameFoldsTotal, MapFoldingState, packageSettings
+from mapFolding.someAssemblyRequired import IfThis, raiseIfNoneGitHubIssueNumber3
+from astToolkit import (
 	Be,
+	ClassIsAndAttribute,
 	extractFunctionDef,
-	IfThis,
 	IngredientsFunction,
 	IngredientsModule,
 	LedgerOfImports,
@@ -13,10 +12,10 @@ from mapFolding.someAssemblyRequired import (
 	NodeTourist,
 	str_nameDOTname,
 	Then,
-	write_astModule,
 )
+from astToolkit.transformationTools import write_astModule
 from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2Numba
-from mapFolding.someAssemblyRequired.toolkitNumba import parametersNumbaLight, SpicesJobNumba, decorateCallableWithNumba
+from mapFolding.someAssemblyRequired.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight, SpicesJobNumba
 from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
 from pathlib import PurePosixPath
 from typing import cast, NamedTuple
@@ -69,15 +68,15 @@ if __name__ == '__main__':
 		writeStream.write(str(foldsTotal))
 		writeStream.close()
 """
-	numba_progressPythonClass: ast_Identifier = 'ProgressBar'
-	numba_progressNumbaType: ast_Identifier = 'ProgressBarType'
+	numba_progressPythonClass: str = 'ProgressBar'
+	numba_progressNumbaType: str = 'ProgressBarType'
 	ingredientsModule.imports.addImportFrom_asStr('numba_progress', numba_progressPythonClass)
 	ingredientsModule.imports.addImportFrom_asStr('numba_progress', numba_progressNumbaType)
 
 	ast_argNumbaProgress = ast.arg(arg=spices.numbaProgressBarIdentifier, annotation=ast.Name(id=numba_progressPythonClass, ctx=ast.Load()))
 	ingredientsFunction.astFunctionDef.args.args.append(ast_argNumbaProgress)
 
-	findThis = ClassIsAndAttribute.targetIs(ast.AugAssign, IfThis.isName_Identifier(job.shatteredDataclass.countingVariableName.id)) # type: ignore
+	findThis = ClassIsAndAttribute.targetIs(ast.AugAssign, IfThis.isName_Identifier(job.shatteredDataclass.countingVariableName.id))
 	doThat = Then.replaceWith(Make.Expr(Make.Call(Make.Attribute(Make.Name(spices.numbaProgressBarIdentifier),'update'),[Make.Constant(1)])))
 	countWithProgressBar = NodeChanger(findThis, doThat)
 	countWithProgressBar.visit(ingredientsFunction.astFunctionDef)
@@ -117,11 +116,11 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 	ingredientsFunction.imports.update(job.shatteredDataclass.imports)
 
 	list_argCuzMyBrainRefusesToThink = ingredientsFunction.astFunctionDef.args.args + ingredientsFunction.astFunctionDef.args.posonlyargs + ingredientsFunction.astFunctionDef.args.kwonlyargs
-	list_arg_arg: list[ast_Identifier] = [ast_arg.arg for ast_arg in list_argCuzMyBrainRefusesToThink]
+	list_arg_arg: list[str] = [ast_arg.arg for ast_arg in list_argCuzMyBrainRefusesToThink]
 	listName: list[ast.Name] = []
 	NodeTourist(Be.Name, Then.appendTo(listName)).visit(ingredientsFunction.astFunctionDef)
-	list_Identifiers: list[ast_Identifier] = [astName.id for astName in listName]
-	list_IdentifiersNotUsed: list[ast_Identifier] = list(set(list_arg_arg) - set(list_Identifiers))
+	list_Identifiers: list[str] = [astName.id for astName in listName]
+	list_IdentifiersNotUsed: list[str] = list(set(list_arg_arg) - set(list_Identifiers))
 
 	for ast_arg in list_argCuzMyBrainRefusesToThink:
 		if ast_arg.arg in job.shatteredDataclass.field2AnnAssign:
@@ -184,7 +183,7 @@ def makeJobNumba(job: RecipeJobTheorem2Numba, spices: SpicesJobNumba) -> None:
 if __name__ == '__main__':
 	import time
 	timeStart = time.perf_counter()
-	foldsTotal = {job.countCallable}() * {job.state.leavesTotal}
+	foldsTotal = int({job.countCallable}() * {job.state.leavesTotal})
 	print(time.perf_counter() - timeStart)
 	print('\\nmap {job.state.mapShape} =', foldsTotal)
 	writeStream = open('{job.pathFilenameFoldsTotal.as_posix()}', 'w')
@@ -202,9 +201,9 @@ if __name__ == '__main__':
 
 	class DatatypeConfig(NamedTuple):
 		Z0Z_module: str_nameDOTname
-		fml: ast_Identifier
-		Z0Z_type_name: ast_Identifier
-		Z0Z_asname: ast_Identifier | None = None
+		fml: str
+		Z0Z_type_name: str
+		Z0Z_asname: str | None = None
 
 	listDatatypeConfigs = [
 		DatatypeConfig(fml='DatatypeLeavesTotal', Z0Z_module='numba', Z0Z_type_name='uint8'),
@@ -267,7 +266,7 @@ if __name__ == '__main__':
 	# foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal
 	# foldsTotalEstimated = dictionaryEstimates[state.mapShape] // state.leavesTotal
 	foldsTotalEstimated = 0
-	pathModule = PurePosixPath(The.pathPackage, 'jobs')
+	pathModule = PurePosixPath(packageSettings.pathPackage, 'jobs')
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
 	aJob = RecipeJobTheorem2Numba(state, foldsTotalEstimated, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
 	spices = SpicesJobNumba(useNumbaProgressBar=False, parametersNumba=parametersNumbaLight)

mapFolding/someAssemblyRequired/toolkitNumba.py

@@ -17,16 +17,13 @@ performance improvements while preserving code semantics and correctness.
 
 from collections.abc import Callable, Sequence
 from mapFolding import NotRequired, TypedDict
-from mapFolding.someAssemblyRequired import ast_Identifier, IngredientsFunction, Make, RecipeSynthesizeFlow, str_nameDOTname, write_astModule
-from mapFolding.someAssemblyRequired.transformationTools import makeNewFlow
+from astToolkit import  IngredientsFunction, Make, str_nameDOTname
+from astToolkit.transformationTools import write_astModule
 from numba.core.compiler import CompilerBase as numbaCompilerBase
 from typing import Any, cast, Final
 import ast
 import dataclasses
 
-# Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
-theNumbaFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()
-
 class ParametersNumba(TypedDict):
 	_dbg_extend_lifetimes: NotRequired[bool]
 	_dbg_optnone: NotRequired[bool]
@@ -56,7 +53,7 @@ parametersNumbaDefault: Final[ParametersNumba] = { '_nrt': True, 'boundscheck':
 parametersNumbaLight: Final[ParametersNumba] = {'cache': True, 'error_model': 'numpy', 'fastmath': True, 'forceinline': True}
 
 Z0Z_numbaDataTypeModule: str_nameDOTname = 'numba'
-Z0Z_decoratorCallable: ast_Identifier = 'jit'
+Z0Z_decoratorCallable: str = 'jit'
 
 def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, parametersNumba: ParametersNumba | None = None) -> IngredientsFunction:
 	def Z0Z_UnhandledDecorators(astCallable: ast.FunctionDef) -> ast.FunctionDef:
@@ -128,47 +125,8 @@ def decorateCallableWithNumba(ingredientsFunction: IngredientsFunction, paramete
 	ingredientsFunction.astFunctionDef.decorator_list = [astDecorator]
 	return ingredientsFunction
 
-# Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
 @dataclasses.dataclass
 class SpicesJobNumba:
 	useNumbaProgressBar: bool = True
-	numbaProgressBarIdentifier: ast_Identifier = 'ProgressBarGroupsOfFolds'
+	numbaProgressBarIdentifier: str = 'ProgressBarGroupsOfFolds'
 	parametersNumba: ParametersNumba = dataclasses.field(default_factory=ParametersNumba) # type: ignore
-
-# Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
-def makeNumbaFlow(numbaFlow: RecipeSynthesizeFlow) -> None:
-	"""
-	Transform standard Python algorithm code into optimized Numba implementations.
-
-	This function implements the complete transformation assembly line that converts
-	a conventional Python implementation into a high-performance Numba-accelerated
-	version. The process includes:
-
-	1. Extracting core algorithm functions from the source module
-	2. Inlining function calls to create self-contained implementations
-	3. Transforming dataclass access patterns for Numba compatibility
-	4. Applying appropriate Numba decorators with optimization settings
-	5. Generating a unified module with sequential and parallel implementations
-	6. Writing the transformed code to the filesystem with properly managed imports
-
-	The transformation preserves the logical structure and semantics of the original
-	implementation while making it compatible with Numba's constraints and
-	optimization capabilities. This creates a bridge between the general-purpose
-	implementation and the highly-optimized version needed for production use.
-
-	Parameters:
-		numbaFlow: Configuration object that specifies all aspects of the
-					transformation process, including source and target locations,
-					function and variable names, and output paths.
-	"""
-
-	ingredientsModuleNumbaUnified = makeNewFlow(numbaFlow)
-
-	# numba decorators =========================================
-	ingredientsModuleNumbaUnified.listIngredientsFunctions[1] = decorateCallableWithNumba(ingredientsModuleNumbaUnified.listIngredientsFunctions[1])
-	ingredientsModuleNumbaUnified.listIngredientsFunctions[2] = decorateCallableWithNumba(ingredientsModuleNumbaUnified.listIngredientsFunctions[2])
-
-	write_astModule(ingredientsModuleNumbaUnified, numbaFlow.pathFilenameDispatcher, numbaFlow.packageIdentifier)
-
-if __name__ == '__main__':
-	makeNumbaFlow(theNumbaFlow)

mapFolding/someAssemblyRequired/transformationTools.py

@@ -18,80 +18,28 @@ readable, maintainable implementations to highly optimized versions while preser
 logical structure and correctness.
 """
 
-from collections.abc import Callable
 from astToolkit import ClassIsAndAttribute
-from mapFolding import outfitCountFolds, ComputationState, The, getPathFilenameFoldsTotal
 from mapFolding.someAssemblyRequired import (
-	ast_Identifier,
-	astModuleToIngredientsFunction,
-	Be,
 	DeReConstructField2ast,
-	extractClassDef,
-	Grab,
 	IfThis,
-	importLogicalPath2Callable,
+	ShatteredDataclass,
+)
+from astToolkit import(
+	Be,
+	extractClassDef,
 	IngredientsFunction,
-	IngredientsModule,
-	inlineFunctionDef,
-	LedgerOfImports,
 	Make,
 	NodeChanger,
-	NodeTourist,
 	parseLogicalPath2astModule,
-	RecipeSynthesizeFlow,
-	removeUnusedParameters,
-	ShatteredDataclass,
 	str_nameDOTname,
 	Then,
-	unparseFindReplace,
 )
-from os import PathLike
-from pathlib import Path, PurePath
-from typing import Any, Literal, overload
+from astToolkit.transformationTools import unparseFindReplace
+from Z0Z_tools import importLogicalPath2Callable
 import ast
 import dataclasses
-import pickle
 
-@overload
-def makeInitializedComputationState(mapShape: tuple[int, ...], writeJob: Literal[True], *,  pathFilename: PathLike[str] | PurePath | None = None, **keywordArguments: Any) -> Path: ...
-@overload
-def makeInitializedComputationState(mapShape: tuple[int, ...], writeJob: Literal[False] = False, **keywordArguments: Any) -> ComputationState: ...
-def makeInitializedComputationState(mapShape: tuple[int, ...], writeJob: bool = False, *,  pathFilename: PathLike[str] | PurePath | None = None, **keywordArguments: Any) -> ComputationState | Path:
-	"""
-	Initializes a computation state and optionally saves it to disk.
-
-	This function initializes a computation state using the source algorithm.
-
-	Hint: If you want an uninitialized state, call `outfitCountFolds` directly.
-
-	Parameters:
-		mapShape: List of integers representing the dimensions of the map to be folded.
-		writeJob (False): Whether to save the state to disk.
-		pathFilename (getPathFilenameFoldsTotal.pkl): The path and filename to save the state. If None, uses a default path.
-		**keywordArguments: computationDivisions:int|str|None=None,concurrencyLimit:int=1.
-	Returns:
-		stateUniversal|pathFilenameJob: The computation state for the map folding calculations, or
-			the path to the saved state file if writeJob is True.
-	"""
-	stateUniversal: ComputationState = outfitCountFolds(mapShape, **keywordArguments)
-
-	initializeState = importLogicalPath2Callable(The.logicalPathModuleSourceAlgorithm, The.sourceCallableInitialize)
-	stateUniversal = initializeState(stateUniversal)
-
-	if not writeJob:
-		return stateUniversal
-
-	if pathFilename:
-		pathFilenameJob = Path(pathFilename)
-		pathFilenameJob.parent.mkdir(parents=True, exist_ok=True)
-	else:
-		pathFilenameJob = getPathFilenameFoldsTotal(stateUniversal.mapShape).with_suffix('.pkl')
-
-	# Fix code scanning alert - Consider possible security implications associated with pickle module. #17
-	pathFilenameJob.write_bytes(pickle.dumps(stateUniversal))
-	return pathFilenameJob
-
-def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclass_Identifier: ast_Identifier, instance_Identifier: ast_Identifier) -> ShatteredDataclass:
+def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclass_Identifier: str, instance_Identifier: str) -> ShatteredDataclass:
 	"""
 	Decompose a dataclass definition into AST components for manipulation and code generation.
 
@@ -121,8 +69,8 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclas
 	Raises:
 		ValueError: If the dataclass cannot be found in the specified module or if no counting variable is identified in the dataclass.
 	"""
-	Official_fieldOrder: list[ast_Identifier] = []
-	dictionaryDeReConstruction: dict[ast_Identifier, DeReConstructField2ast] = {}
+	Official_fieldOrder: list[str] = []
+	dictionaryDeReConstruction: dict[str, DeReConstructField2ast] = {}
 
 	dataclassClassDef = extractClassDef(parseLogicalPath2astModule(logicalPathModule), dataclass_Identifier)
 	if not isinstance(dataclassClassDef, ast.ClassDef): raise ValueError(f"I could not find `{dataclass_Identifier = }` in `{logicalPathModule = }`.")
@@ -160,116 +108,6 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclas
 
 	return shatteredDataclass
 
-# END of acceptable classes and functions ======================================================
-def makeNewFlow(recipeFlow: RecipeSynthesizeFlow) -> IngredientsModule:
-	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-	listAllIngredientsFunctions = [
-	(ingredientsInitialize := astModuleToIngredientsFunction(recipeFlow.source_astModule, recipeFlow.sourceCallableInitialize)),
-	(ingredientsParallel := astModuleToIngredientsFunction(recipeFlow.source_astModule, recipeFlow.sourceCallableParallel)),
-	(ingredientsSequential := astModuleToIngredientsFunction(recipeFlow.source_astModule, recipeFlow.sourceCallableSequential)),
-	(ingredientsDispatcher := astModuleToIngredientsFunction(recipeFlow.source_astModule, recipeFlow.sourceCallableDispatcher)),
-	]
-
-	# Inline functions ========================================================
-	# NOTE Replacements statements are based on the identifiers in the _source_, so operate on the source identifiers.
-	ingredientsInitialize.astFunctionDef = inlineFunctionDef(recipeFlow.sourceCallableInitialize, recipeFlow.source_astModule)
-	ingredientsParallel.astFunctionDef = inlineFunctionDef(recipeFlow.sourceCallableParallel, recipeFlow.source_astModule)
-	ingredientsSequential.astFunctionDef = inlineFunctionDef(recipeFlow.sourceCallableSequential, recipeFlow.source_astModule)
-
-	# assignRecipeIdentifiersToCallable. =============================
-	# Consolidate settings classes through inheritance https://github.com/hunterhogan/mapFolding/issues/15
-	# How can I use dataclass settings as the SSOT for specific actions? https://github.com/hunterhogan/mapFolding/issues/16
-	# NOTE reminder: you are updating these `ast.Name` here (and not in a more general search) because this is a
-	# narrow search for `ast.Call` so you won't accidentally replace unrelated `ast.Name`.
-	listFindReplace = [(recipeFlow.sourceCallableDispatcher, recipeFlow.callableDispatcher),
-						(recipeFlow.sourceCallableInitialize, recipeFlow.callableInitialize),
-						(recipeFlow.sourceCallableParallel, recipeFlow.callableParallel),
-						(recipeFlow.sourceCallableSequential, recipeFlow.callableSequential),]
-	for ingredients in listAllIngredientsFunctions:
-		for source_Identifier, recipe_Identifier in listFindReplace:
-			updateCallName = NodeChanger(IfThis.isCall_Identifier(source_Identifier), Grab.funcAttribute(Then.replaceWith(Make.Name(recipe_Identifier))))
-			updateCallName.visit(ingredients.astFunctionDef)
-
-	ingredientsDispatcher.astFunctionDef.name = recipeFlow.callableDispatcher
-	ingredientsInitialize.astFunctionDef.name = recipeFlow.callableInitialize
-	ingredientsParallel.astFunctionDef.name = recipeFlow.callableParallel
-	ingredientsSequential.astFunctionDef.name = recipeFlow.callableSequential
-
-	# Assign identifiers per the recipe. ==============================
-	listFindReplace = [(recipeFlow.sourceDataclassInstance, recipeFlow.dataclassInstance),
-		(recipeFlow.sourceDataclassInstanceTaskDistribution, recipeFlow.dataclassInstanceTaskDistribution),
-		(recipeFlow.sourceConcurrencyManagerNamespace, recipeFlow.concurrencyManagerNamespace),]
-	for ingredients in listAllIngredientsFunctions:
-		for source_Identifier, recipe_Identifier in listFindReplace:
-			updateName = NodeChanger(IfThis.isName_Identifier(source_Identifier) , Grab.idAttribute(Then.replaceWith(recipe_Identifier)))
-			update_arg = NodeChanger(IfThis.isArgument_Identifier(source_Identifier), Grab.argAttribute(Then.replaceWith(recipe_Identifier)))
-			updateName.visit(ingredients.astFunctionDef)
-			update_arg.visit(ingredients.astFunctionDef)
-
-	updateConcurrencyManager = NodeChanger(IfThis.isCallAttributeNamespace_Identifier(recipeFlow.sourceConcurrencyManagerNamespace, recipeFlow.sourceConcurrencyManagerIdentifier)
-										, Grab.funcAttribute(Then.replaceWith(Make.Attribute(Make.Name(recipeFlow.concurrencyManagerNamespace), recipeFlow.concurrencyManagerIdentifier))))
-	updateConcurrencyManager.visit(ingredientsDispatcher.astFunctionDef)
-
-	# shatter Dataclass =======================================================
-	instance_Identifier = recipeFlow.dataclassInstance
-	getTheOtherRecord_damn = recipeFlow.dataclassInstanceTaskDistribution
-	shatteredDataclass = shatter_dataclassesDOTdataclass(recipeFlow.logicalPathModuleDataclass, recipeFlow.sourceDataclassIdentifier, instance_Identifier)
-	ingredientsDispatcher.imports.update(shatteredDataclass.imports)
-
-	# How can I use dataclass settings as the SSOT for specific actions? https://github.com/hunterhogan/mapFolding/issues/16
-	# Change callable parameters and Call to the callable at the same time ====
-	# sequentialCallable =========================================================
-	if recipeFlow.removeDataclassSequential:
-		ingredientsSequential = removeDataclassFromFunction(ingredientsSequential, shatteredDataclass)
-		ingredientsDispatcher = unpackDataclassCallFunctionRepackDataclass(ingredientsDispatcher, recipeFlow.callableSequential, shatteredDataclass)
-
-	if recipeFlow.removeDataclassInitialize:
-		ingredientsInitialize = removeDataclassFromFunction(ingredientsInitialize, shatteredDataclass)
-		ingredientsDispatcher = unpackDataclassCallFunctionRepackDataclass(ingredientsDispatcher, recipeFlow.callableInitialize, shatteredDataclass)
-
-	# parallelCallable =========================================================
-	if recipeFlow.removeDataclassParallel:
-		ingredientsParallel.astFunctionDef.args = Make.arguments(args=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
-
-		ingredientsParallel.astFunctionDef = unparseFindReplace(ingredientsParallel.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
-
-		ingredientsParallel = removeUnusedParameters(ingredientsParallel)
-
-		list_argCuzMyBrainRefusesToThink = ingredientsParallel.astFunctionDef.args.args + ingredientsParallel.astFunctionDef.args.posonlyargs + ingredientsParallel.astFunctionDef.args.kwonlyargs
-		list_arg_arg: list[ast_Identifier] = [ast_arg.arg for ast_arg in list_argCuzMyBrainRefusesToThink]
-
-		listParameters = [parameter for parameter in shatteredDataclass.listName4Parameters if parameter.id in list_arg_arg]
-
-		replaceCall2concurrencyManager = NodeChanger(IfThis.isCallAttributeNamespace_Identifier(recipeFlow.concurrencyManagerNamespace, recipeFlow.concurrencyManagerIdentifier), Then.replaceWith(Make.Call(Make.Attribute(Make.Name(recipeFlow.concurrencyManagerNamespace), recipeFlow.concurrencyManagerIdentifier), [Make.Name(recipeFlow.callableParallel)] + listParameters)))
-
-		def getIt(astCallConcurrencyResult: list[ast.Call]) -> Callable[[ast.AST], ast.AST]:
-			# TODO I cannot remember why I made this function. It doesn't fit with how I normally do things.
-			def workhorse(node: ast.AST) -> ast.AST:
-				NodeTourist(Be.Call, Then.appendTo(astCallConcurrencyResult)).visit(node)
-				return node
-			return workhorse
-
-		# NOTE I am dissatisfied with this logic for many reasons, including that it requires separate NodeCollector and NodeReplacer instances.
-		astCallConcurrencyResult: list[ast.Call] = []
-		get_astCallConcurrencyResult = NodeTourist(IfThis.isAssignAndTargets0Is(IfThis.isSubscript_Identifier(getTheOtherRecord_damn)), getIt(astCallConcurrencyResult))
-		get_astCallConcurrencyResult.visit(ingredientsDispatcher.astFunctionDef)
-		replaceAssignParallelCallable = NodeChanger(IfThis.isAssignAndTargets0Is(IfThis.isSubscript_Identifier(getTheOtherRecord_damn)), Grab.valueAttribute(Then.replaceWith(astCallConcurrencyResult[0])))
-		replaceAssignParallelCallable.visit(ingredientsDispatcher.astFunctionDef)
-		changeReturnParallelCallable = NodeChanger(Be.Return, Then.replaceWith(Make.Return(shatteredDataclass.countingVariableName)))
-		ingredientsParallel.astFunctionDef.returns = shatteredDataclass.countingVariableAnnotation
-
-		unpack4parallelCallable = NodeChanger(ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCallAttributeNamespace_Identifier(recipeFlow.concurrencyManagerNamespace, recipeFlow.concurrencyManagerIdentifier)), Then.insertThisAbove(shatteredDataclass.listUnpack))
-
-		unpack4parallelCallable.visit(ingredientsDispatcher.astFunctionDef)
-		replaceCall2concurrencyManager.visit(ingredientsDispatcher.astFunctionDef)
-		changeReturnParallelCallable.visit(ingredientsParallel.astFunctionDef)
-
-	# Module-level transformations ===========================================================
-	ingredientsModuleNumbaUnified = IngredientsModule(ingredientsFunction=listAllIngredientsFunctions, imports=LedgerOfImports(recipeFlow.source_astModule))
-	ingredientsModuleNumbaUnified.removeImportFromModule('numpy')
-
-	return ingredientsModuleNumbaUnified
-
 def removeDataclassFromFunction(ingredientsTarget: IngredientsFunction, shatteredDataclass: ShatteredDataclass) -> IngredientsFunction:
 	ingredientsTarget.astFunctionDef.args = Make.arguments(args=shatteredDataclass.list_argAnnotated4ArgumentsSpecification)
 	ingredientsTarget.astFunctionDef.returns = shatteredDataclass.signatureReturnAnnotation
@@ -278,7 +116,7 @@ def removeDataclassFromFunction(ingredientsTarget: IngredientsFunction, shattere
 	ingredientsTarget.astFunctionDef = unparseFindReplace(ingredientsTarget.astFunctionDef, shatteredDataclass.map_stateDOTfield2Name)
 	return ingredientsTarget
 
-def unpackDataclassCallFunctionRepackDataclass(ingredientsCaller: IngredientsFunction, targetCallableIdentifier: ast_Identifier, shatteredDataclass: ShatteredDataclass) -> IngredientsFunction:
+def unpackDataclassCallFunctionRepackDataclass(ingredientsCaller: IngredientsFunction, targetCallableIdentifier: str, shatteredDataclass: ShatteredDataclass) -> IngredientsFunction:
 	astCallTargetCallable = Make.Call(Make.Name(targetCallableIdentifier), shatteredDataclass.listName4Parameters)
 	replaceAssignTargetCallable = NodeChanger(ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCall_Identifier(targetCallableIdentifier)), Then.replaceWith(Make.Assign([shatteredDataclass.fragments4AssignmentOrParameters], value=astCallTargetCallable)))
 	unpack4targetCallable = NodeChanger(ClassIsAndAttribute.valueIs(ast.Assign, IfThis.isCall_Identifier(targetCallableIdentifier)), Then.insertThisAbove(shatteredDataclass.listUnpack))
@@ -287,11 +125,3 @@ def unpackDataclassCallFunctionRepackDataclass(ingredientsCaller: IngredientsFun
 	unpack4targetCallable.visit(ingredientsCaller.astFunctionDef)
 	repack4targetCallable.visit(ingredientsCaller.astFunctionDef)
 	return ingredientsCaller
-
-dictionaryEstimates: dict[tuple[int, ...], int] = {
-	(2,2,2,2,2,2,2,2): 798148657152000,
-	(2,21): 776374224866624,
-	(3,15): 824761667826225,
-	(3,3,3,3): 85109616000000000000000000000000,
-	(8,8): 791274195985524900,
-}

mapFolding/theSSOT.py

@@ -5,25 +5,30 @@ from tomli import load as tomli_load
 import dataclasses
 
 packageNamePACKAGING_HARDCODED = "mapFolding"
+concurrencyPackageHARDCODED = 'multiprocessing'
 
-# Evaluate When Packaging https://github.com/hunterhogan/mapFolding/issues/18
+# Evaluate When Packaging
+# https://github.com/hunterhogan/mapFolding/issues/18
 try:
 	packageNamePACKAGING: str = tomli_load(Path("../pyproject.toml").open('rb'))["project"]["name"]
 except Exception:
 	packageNamePACKAGING = packageNamePACKAGING_HARDCODED
 
-# Evaluate When Installing https://github.com/hunterhogan/mapFolding/issues/18
+# Evaluate When Installing
+# https://github.com/hunterhogan/mapFolding/issues/18
 def getPathPackageINSTALLING() -> Path:
 	pathPackage: Path = Path(inspect_getfile(importlib_import_module(packageNamePACKAGING)))
 	if pathPackage.is_file():
 		pathPackage = pathPackage.parent
 	return pathPackage
 
-# PackageSettings in theSSOT.py and immutability https://github.com/hunterhogan/mapFolding/issues/11
 @dataclasses.dataclass
 class PackageSettings:
 	fileExtension: str = dataclasses.field(default='.py', metadata={'evaluateWhen': 'installing'})
 	packageName: str = dataclasses.field(default = packageNamePACKAGING, metadata={'evaluateWhen': 'packaging'})
 	pathPackage: Path = dataclasses.field(default_factory=getPathPackageINSTALLING, metadata={'evaluateWhen': 'installing'})
+	concurrencyPackage: str | None = None
+	"""Package to use for concurrent execution (e.g., 'multiprocessing', 'numba')."""
 
-packageSettings = PackageSettings()
+concurrencyPackage = concurrencyPackageHARDCODED
+packageSettings = PackageSettings(concurrencyPackage=concurrencyPackage)