mapFolding 0.11.2__py3-none-any.whl → 0.11.3__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 ast_Identifier, 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

mapFolding/{infoBooth.py → someAssemblyRequired/infoBooth.py}

@@ -1,27 +1,13 @@
-from collections.abc import Callable
-from importlib import import_module as importlib_import_module
-from mapFolding import ComputationState, PackageSettings
-from types import ModuleType
+from mapFolding import PackageSettings
 import dataclasses
 
 @dataclasses.dataclass
 class PackageInformation(PackageSettings):
-	"""
-	In _all_ of the root directory and "syntheticModules", the _only_ `PackageInformation` that are used are:
-		The.concurrencyPackage
-		The.dispatcher
-	"""
-
-	logicalPathModuleDispatcher: str | None = None
-	"""Logical import path to the module containing the dispatcher function."""
-
-	callableDispatcher: str | None = None
+	callableDispatcher: str = 'doTheNeedful'
 	"""Name of the function within the dispatcher module that will be called."""
 
-	concurrencyPackage: str | None = None
-	"""Package to use for concurrent execution (e.g., 'multiprocessing', 'numba')."""
-
-	# "Evaluate When Packaging" and "Evaluate When Installing" https://github.com/hunterhogan/mapFolding/issues/18
+	# "Evaluate When Packaging" and "Evaluate When Installing"
+	# https://github.com/hunterhogan/mapFolding/issues/18
 	dataclassIdentifier: str = dataclasses.field(default='ComputationState', metadata={'evaluateWhen': 'packaging'})
 	"""Name of the dataclass used to track computation state."""
 
@@ -70,14 +56,6 @@ class PackageInformation(PackageSettings):
 	logicalPathModuleSourceAlgorithm: str = dataclasses.field(default=None, metadata={'evaluateWhen': 'packaging'}) # pyright: ignore[reportAssignmentType]
 	"""Fully qualified import path to the module containing the source algorithm."""
 
-	@property
-	def dispatcher(self) -> Callable[['ComputationState'], 'ComputationState']:
-		""" _The_ callable that connects `countFolds` to the logic that does the work."""
-		logicalPath: str = self.logicalPathModuleDispatcher or self.logicalPathModuleSourceAlgorithm
-		identifier: str = self.callableDispatcher or self.sourceCallableDispatcher
-		moduleImported: ModuleType = importlib_import_module(logicalPath)
-		return getattr(moduleImported, identifier)
-
 	def __post_init__(self) -> None:
 		if self.dataclassInstanceTaskDistribution is None: # pyright: ignore[reportUnnecessaryComparison]
 			self.dataclassInstanceTaskDistribution = self.dataclassInstance + self.dataclassInstanceTaskDistributionSuffix
@@ -89,8 +67,4 @@ class PackageInformation(PackageSettings):
 
 class raiseIfNoneGitHubIssueNumber3(Exception): pass
 
-logicalPathModuleDispatcherHARDCODED: str = 'mapFolding.syntheticModules.numbaCount'
-callableDispatcherHARDCODED: str = 'doTheNeedful'
-concurrencyPackageHARDCODED = 'multiprocessing'
-
-The = PackageInformation(logicalPathModuleDispatcher=logicalPathModuleDispatcherHARDCODED, callableDispatcher=callableDispatcherHARDCODED, concurrencyPackage=concurrencyPackageHARDCODED)
+packageInformation = PackageInformation()

mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py

@@ -1,10 +1,10 @@
-from astToolkit import ClassIsAndAttribute
-from mapFolding import getPathFilenameFoldsTotal, raiseIfNoneGitHubIssueNumber3, The, MapFoldingState
-from mapFolding.someAssemblyRequired import (
+from mapFolding import getPathFilenameFoldsTotal, MapFoldingState
+from mapFolding.someAssemblyRequired import IfThis, packageInformation, raiseIfNoneGitHubIssueNumber3
+from astToolkit import (
 	ast_Identifier,
 	Be,
+	ClassIsAndAttribute,
 	extractFunctionDef,
-	IfThis,
 	IngredientsFunction,
 	IngredientsModule,
 	LedgerOfImports,
@@ -13,10 +13,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
@@ -77,7 +77,7 @@ if __name__ == '__main__':
 	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)
@@ -184,7 +184,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')
@@ -267,7 +267,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(packageInformation.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 ast_Identifier, 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]
@@ -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'
 	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,78 +18,27 @@ 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 (
+	DeReConstructField2ast,
+	IfThis,
+	ShatteredDataclass,
+)
+from astToolkit import(
 	ast_Identifier,
-	astModuleToIngredientsFunction,
 	Be,
-	DeReConstructField2ast,
 	extractClassDef,
-	Grab,
-	IfThis,
-	importLogicalPath2Callable,
 	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:
 	"""
@@ -161,114 +110,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)

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)

{mapfolding-0.11.2.dist-info → mapfolding-0.11.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.11.2
+Version: 0.11.3
 Summary: Map folding algorithm with code transformation framework for optimizing numerical computations
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -33,8 +33,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: astToolkit
 Requires-Dist: autoflake
-Requires-Dist: cytoolz
-Requires-Dist: more_itertools
 Requires-Dist: numba_progress
 Requires-Dist: numba
 Requires-Dist: numpy
@@ -42,7 +40,6 @@ Requires-Dist: platformdirs
 Requires-Dist: python_minifier
 Requires-Dist: sympy
 Requires-Dist: tomli
-Requires-Dist: typeshed_client
 Requires-Dist: Z0Z_tools
 Provides-Extra: testing
 Requires-Dist: mypy; extra == "testing"