mapFolding 0.8.4__py3-none-any.whl → 0.8.5__py3-none-any.whl

mapFolding/someAssemblyRequired/transformationTools.py

@@ -25,14 +25,40 @@ transformation scenarios beyond the scope of this package.
 from autoflake import fix_code as autoflake_fix_code
 from collections.abc import Callable, Mapping
 from copy import deepcopy
-from mapFolding.filesystem import writeStringToHere
-from mapFolding.someAssemblyRequired import ast_Identifier, be, ifThis, Make, NodeChanger, NodeTourist, Then, typeCertified
-from mapFolding.someAssemblyRequired._toolboxContainers import IngredientsModule
-from mapFolding.theSSOT import raiseIfNoneGitHubIssueNumber3
+from mapFolding.beDRY import outfitCountFolds
+from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal, writeStringToHere
+from mapFolding.someAssemblyRequired import (
+	ast_Identifier,
+	be,
+	DOT,
+	ifThis,
+	ImaAnnotationType,
+	importLogicalPath2Callable,
+	IngredientsFunction,
+	IngredientsModule,
+	LedgerOfImports,
+	Make,
+	NodeChanger,
+	NodeTourist,
+	parseLogicalPath2astModule,
+	ShatteredDataclass,
+	str_nameDOTname,
+	Then,
+	TypeCertified,
+	又,
+)
+from mapFolding.theSSOT import ComputationState, The, raiseIfNoneGitHubIssueNumber3
 from os import PathLike
-from pathlib import PurePath
-from typing import Any
+from pathlib import Path, PurePath
+from typing import Any, Literal, overload
 import ast
+import dataclasses
+import pickle
+
+def astModuleToIngredientsFunction(astModule: ast.AST, identifierFunctionDef: ast_Identifier) -> IngredientsFunction:
+	astFunctionDef = extractFunctionDef(astModule, identifierFunctionDef)
+	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
+	return IngredientsFunction(astFunctionDef, LedgerOfImports(astModule))
 
 def extractClassDef(module: ast.AST, identifier: ast_Identifier) -> ast.ClassDef | None:
 	return NodeTourist(ifThis.isClassDef_Identifier(identifier), Then.getIt).captureLastMatch(module)
@@ -40,6 +66,221 @@ def extractClassDef(module: ast.AST, identifier: ast_Identifier) -> ast.ClassDef
 def extractFunctionDef(module: ast.AST, identifier: ast_Identifier) -> ast.FunctionDef | None:
 	return NodeTourist(ifThis.isFunctionDef_Identifier(identifier), Then.getIt).captureLastMatch(module)
 
+def makeDictionaryFunctionDef(module: ast.AST) -> dict[ast_Identifier, ast.FunctionDef]:
+	dictionaryIdentifier2FunctionDef: dict[ast_Identifier, ast.FunctionDef] = {}
+	NodeTourist(be.FunctionDef, Then.updateKeyValueIn(DOT.name, Then.getIt, dictionaryIdentifier2FunctionDef)).visit(module)
+	return dictionaryIdentifier2FunctionDef
+
+def makeDictionary4InliningFunction(identifierToInline: ast_Identifier, dictionaryFunctionDef: dict[ast_Identifier, ast.FunctionDef], FunctionDefToInline: ast.FunctionDef | None = None) -> dict[str, ast.FunctionDef]:
+	"""
+	Creates a dictionary of function definitions required for inlining a target function.
+	This function analyzes a target function and recursively collects all function definitions
+	that are called within it (and any functions called by those functions), preparing them for inlining.
+	Parameters:
+	----------
+	identifierToInline : ast_Identifier
+		The identifier of the function to be inlined.
+	dictionaryFunctionDef : dict[ast_Identifier, ast.FunctionDef]
+		A dictionary mapping function identifiers to their AST function definitions.
+	FunctionDefToInline : ast.FunctionDef | None, optional
+		The AST function definition to inline. If None, it will be retrieved from dictionaryFunctionDef using identifierToInline.
+	Returns:
+	-------
+	dict[str, ast.FunctionDef]
+		A dictionary mapping function names to their AST function definitions, containing all functions needed for inlining.
+	Raises:
+	------
+	ValueError
+		If the function to inline is not found in the dictionary, or if recursion is detected during analysis.
+	Notes:
+	-----
+	The function performs a recursive analysis to find all dependent functions needed for inlining.
+	It detects and prevents recursive function calls that could cause infinite inlining.
+	"""
+	if FunctionDefToInline is None:
+		try:
+			FunctionDefToInline = dictionaryFunctionDef[identifierToInline]
+		except KeyError as ERRORmessage:
+			raise ValueError(f"FunctionDefToInline not found in dictionaryIdentifier2FunctionDef: {identifierToInline = }") from ERRORmessage
+
+	listIdentifiersCalledFunctions: list[ast_Identifier] = []
+	findIdentifiersToInline = NodeTourist(ifThis.isCallToName, lambda node: Then.appendTo(listIdentifiersCalledFunctions)(DOT.id(DOT.func(node)))) # pyright: ignore[reportArgumentType]
+	findIdentifiersToInline.visit(FunctionDefToInline)
+
+	dictionary4Inlining: dict[ast_Identifier, ast.FunctionDef] = {}
+	for identifier in sorted(set(listIdentifiersCalledFunctions).intersection(dictionaryFunctionDef.keys())):
+		dictionary4Inlining[identifier] = dictionaryFunctionDef[identifier]
+
+	keepGoing = True
+	while keepGoing:
+		keepGoing = False
+		listIdentifiersCalledFunctions.clear()
+		findIdentifiersToInline.visit(Make.Module(list(dictionary4Inlining.values())))
+
+		# NOTE: This is simple not comprehensive recursion protection. # TODO think about why I dislike `ifThis.CallDoesNotCallItself`
+		if identifierToInline in listIdentifiersCalledFunctions: raise ValueError(f"Recursion found: {identifierToInline = }.")
+
+		listIdentifiersCalledFunctions = sorted((set(listIdentifiersCalledFunctions).difference(dictionary4Inlining.keys())).intersection(dictionaryFunctionDef.keys()))
+		if len(listIdentifiersCalledFunctions) > 0:
+			keepGoing = True
+			for identifier in listIdentifiersCalledFunctions:
+				if identifier in dictionaryFunctionDef:
+					dictionary4Inlining[identifier] = dictionaryFunctionDef[identifier]
+
+	return dictionary4Inlining
+
+@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')
+
+	pathFilenameJob.write_bytes(pickle.dumps(stateUniversal))
+	return pathFilenameJob
+
+@dataclasses.dataclass
+class DeReConstructField2ast:
+	dataclassesDOTdataclassLogicalPathModule: dataclasses.InitVar[str_nameDOTname]
+	dataclassClassDef: dataclasses.InitVar[ast.ClassDef]
+	dataclassesDOTdataclassInstance_Identifier: dataclasses.InitVar[ast_Identifier]
+	field: dataclasses.InitVar[dataclasses.Field[Any]]
+
+	ledger: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
+
+	name: ast_Identifier = 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)
+	repr: bool = dataclasses.field(init=False)
+	hash: bool | None = dataclasses.field(init=False)
+	init: bool = dataclasses.field(init=False)
+	compare: bool = dataclasses.field(init=False)
+	metadata: dict[Any, Any] = dataclasses.field(init=False)
+	kw_only: bool = dataclasses.field(init=False)
+
+	astName: ast.Name = dataclasses.field(init=False)
+	ast_keyword_field__field: ast.keyword = dataclasses.field(init=False)
+	ast_nameDOTname: ast.Attribute = dataclasses.field(init=False)
+	astAnnotation: ImaAnnotationType = dataclasses.field(init=False)
+	ast_argAnnotated: ast.arg = dataclasses.field(init=False)
+	astAnnAssignConstructor: ast.AnnAssign = dataclasses.field(init=False)
+	Z0Z_hack: tuple[ast.AnnAssign, str] = dataclasses.field(init=False)
+
+	def __post_init__(self, dataclassesDOTdataclassLogicalPathModule: str_nameDOTname, dataclassClassDef: ast.ClassDef, dataclassesDOTdataclassInstance_Identifier: ast_Identifier, 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
+		self.hash = field.hash
+		self.init = field.init
+		self.kw_only = field.kw_only if field.kw_only is not dataclasses.MISSING else False
+		self.metadata = dict(field.metadata)
+		self.name = field.name
+		self.repr = field.repr
+		self.typeBuffalo = field.type
+
+		self.astName = Make.Name(self.name)
+		self.ast_keyword_field__field = Make.keyword(self.name, self.astName)
+		self.ast_nameDOTname = Make.Attribute(Make.Name(dataclassesDOTdataclassInstance_Identifier), self.name)
+
+		sherpa = NodeTourist(ifThis.isAnnAssign_targetIs(ifThis.isName_Identifier(self.name)), 又.annotation(Then.getIt)).captureLastMatch(dataclassClassDef)
+		if sherpa is None: raise raiseIfNoneGitHubIssueNumber3
+		else: self.astAnnotation = sherpa
+
+		self.ast_argAnnotated = Make.arg(self.name, self.astAnnotation)
+
+		dtype = self.metadata.get('dtype', None)
+		if dtype:
+			constructor = 'array'
+			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, Make.Call(Make.Name(constructor), list_astKeywords=[Make.keyword('dtype', Make.Name(dtype.__name__))]))
+			self.ledger.addImportFrom_asStr('numpy', constructor)
+			self.ledger.addImportFrom_asStr('numpy', dtype.__name__)
+			self.Z0Z_hack = (self.astAnnAssignConstructor, 'array')
+		elif be.Name(self.astAnnotation):
+			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, Make.Call(self.astAnnotation, [Make.Constant(-1)]))
+			self.ledger.addImportFrom_asStr(dataclassesDOTdataclassLogicalPathModule, self.astAnnotation.id)
+			self.Z0Z_hack = (self.astAnnAssignConstructor, 'scalar')
+		elif be.Subscript(self.astAnnotation):
+			elementConstructor: ast_Identifier = self.metadata['elementConstructor']
+			self.ledger.addImportFrom_asStr(dataclassesDOTdataclassLogicalPathModule, elementConstructor)
+			takeTheTuple: ast.Tuple = deepcopy(self.astAnnotation.slice) # type: ignore
+			self.astAnnAssignConstructor = Make.AnnAssign(self.astName, self.astAnnotation, takeTheTuple)
+			self.Z0Z_hack = (self.astAnnAssignConstructor, elementConstructor)
+		if be.Name(self.astAnnotation):
+			self.ledger.addImportFrom_asStr(dataclassesDOTdataclassLogicalPathModule, self.astAnnotation.id) # pyright: ignore [reportUnknownArgumentType, reportUnknownMemberType, reportIJustCalledATypeGuardMethod_WTF]
+
+def shatter_dataclassesDOTdataclass(logicalPathModule: str_nameDOTname, dataclass_Identifier: ast_Identifier, instance_Identifier: ast_Identifier) -> ShatteredDataclass:
+	"""
+	Parameters:
+		logicalPathModule: gimme string cuz python is stoopid
+		dataclass_Identifier: The identifier of the dataclass to be dismantled.
+		instance_Identifier: In the synthesized module/function/scope, the identifier that will be used for the instance.
+	"""
+	Official_fieldOrder: list[ast_Identifier] = []
+	dictionaryDeReConstruction: dict[ast_Identifier, DeReConstructField2ast] = {}
+
+	dataclassClassDef = extractClassDef(parseLogicalPath2astModule(logicalPathModule), dataclass_Identifier)
+	if not isinstance(dataclassClassDef, ast.ClassDef): raise ValueError(f"I could not find {dataclass_Identifier=} in {logicalPathModule=}.")
+
+	countingVariable = None
+	for aField in dataclasses.fields(importLogicalPath2Callable(logicalPathModule, dataclass_Identifier)): # pyright: ignore [reportArgumentType]
+		Official_fieldOrder.append(aField.name)
+		dictionaryDeReConstruction[aField.name] = DeReConstructField2ast(logicalPathModule, dataclassClassDef, instance_Identifier, aField)
+		if aField.metadata.get('theCountingIdentifier', False):
+			countingVariable = dictionaryDeReConstruction[aField.name].name
+
+	if countingVariable is None:
+		raise ValueError(f"I could not find the counting variable in {dataclass_Identifier=} in {logicalPathModule=}.")
+
+	shatteredDataclass = ShatteredDataclass(
+		countingVariableAnnotation=dictionaryDeReConstruction[countingVariable].astAnnotation,
+		countingVariableName=dictionaryDeReConstruction[countingVariable].astName,
+		field2AnnAssign={dictionaryDeReConstruction[field].name: dictionaryDeReConstruction[field].astAnnAssignConstructor for field in Official_fieldOrder},
+		Z0Z_field2AnnAssign={dictionaryDeReConstruction[field].name: dictionaryDeReConstruction[field].Z0Z_hack for field in Official_fieldOrder},
+		list_argAnnotated4ArgumentsSpecification=[dictionaryDeReConstruction[field].ast_argAnnotated for field in Official_fieldOrder],
+		list_keyword_field__field4init=[dictionaryDeReConstruction[field].ast_keyword_field__field for field in Official_fieldOrder if dictionaryDeReConstruction[field].init],
+		listAnnotations=[dictionaryDeReConstruction[field].astAnnotation for field in Official_fieldOrder],
+		listName4Parameters=[dictionaryDeReConstruction[field].astName for field in Official_fieldOrder],
+		listUnpack=[Make.AnnAssign(dictionaryDeReConstruction[field].astName, dictionaryDeReConstruction[field].astAnnotation, dictionaryDeReConstruction[field].ast_nameDOTname) for field in Official_fieldOrder],
+		map_stateDOTfield2Name={dictionaryDeReConstruction[field].ast_nameDOTname: dictionaryDeReConstruction[field].astName for field in Official_fieldOrder},
+		)
+	shatteredDataclass.fragments4AssignmentOrParameters = Make.Tuple(shatteredDataclass.listName4Parameters, ast.Store())
+	shatteredDataclass.repack = Make.Assign(listTargets=[Make.Name(instance_Identifier)], value=Make.Call(Make.Name(dataclass_Identifier), list_astKeywords=shatteredDataclass.list_keyword_field__field4init))
+	shatteredDataclass.signatureReturnAnnotation = Make.Subscript(Make.Name('tuple'), Make.Tuple(shatteredDataclass.listAnnotations))
+
+	shatteredDataclass.ledger.update(*(dictionaryDeReConstruction[field].ledger for field in Official_fieldOrder))
+	shatteredDataclass.ledger.addImportFrom_asStr(logicalPathModule, dataclass_Identifier)
+
+	return shatteredDataclass
+
 def write_astModule(ingredients: IngredientsModule, pathFilename: PathLike[Any] | PurePath, packageName: ast_Identifier | None = None) -> None:
 	astModule = Make.Module(ingredients.body, ingredients.type_ignores)
 	ast.fix_missing_locations(astModule)
@@ -52,12 +293,6 @@ def write_astModule(ingredients: IngredientsModule, pathFilename: PathLike[Any]
 	writeStringToHere(pythonSource, pathFilename)
 
 # END of acceptable classes and functions ======================================================
-
-def makeDictionaryFunctionDef(module: ast.AST) -> dict[ast_Identifier, ast.FunctionDef]:
-	dictionaryFunctionDef: dict[ast_Identifier, ast.FunctionDef] = {}
-	NodeTourist(be.FunctionDef, Then.updateThis(dictionaryFunctionDef)).visit(module)
-	return dictionaryFunctionDef
-
 dictionaryEstimates: dict[tuple[int, ...], int] = {
 	(2,2,2,2,2,2,2,2): 362794844160000,
 	(2,21): 1493028892051200,
@@ -67,7 +302,7 @@ dictionaryEstimates: dict[tuple[int, ...], int] = {
 }
 
 # END of marginal classes and functions ======================================================
-def Z0Z_lameFindReplace(astTree: typeCertified, mappingFindReplaceNodes: Mapping[ast.AST, ast.AST]) -> typeCertified:
+def Z0Z_lameFindReplace(astTree, mappingFindReplaceNodes: Mapping[ast.AST, ast.AST]):
 	keepGoing = True
 	newTree = deepcopy(astTree)
 
@@ -82,37 +317,15 @@ def Z0Z_lameFindReplace(astTree: typeCertified, mappingFindReplaceNodes: Mapping
 	return newTree
 
 # Start of I HATE PROGRAMMING ==========================================================
-# Similar functionality to call does not call itself, but it is used for something else. I hate this function, too.
-def Z0Z_descendantContainsMatchingNode(node: ast.AST, predicateFunction: Callable[[ast.AST], bool]) -> bool:
-	"""Return True if any descendant of the node (or the node itself) matches the predicateFunction."""
-	matchFound = False
-	class DescendantFinder(ast.NodeVisitor):
-		def generic_visit(self, node: ast.AST) -> None:
-			nonlocal matchFound
-			if predicateFunction(node):
-				matchFound = True
-			else:
-				super().generic_visit(node)
-	DescendantFinder().visit(node)
-	return matchFound
-
-def Z0Z_executeActionUnlessDescendantMatches(exclusionPredicate: Callable[[ast.AST], bool], actionFunction: Callable[[ast.AST], None]) -> Callable[[ast.AST], None]:
-	"""Return a new action that will execute actionFunction only if no descendant (or the node itself) matches exclusionPredicate."""
-	def wrappedAction(node: ast.AST) -> None:
-		if not Z0Z_descendantContainsMatchingNode(node, exclusionPredicate):
-			actionFunction(node)
-	return wrappedAction
-
-# Inlining functions ==========================================================
 def Z0Z_makeDictionaryReplacementStatements(module: ast.AST) -> dict[ast_Identifier, ast.stmt | list[ast.stmt]]:
 	"""Return a dictionary of function names and their replacement statements."""
 	dictionaryFunctionDef: dict[ast_Identifier, ast.FunctionDef] = makeDictionaryFunctionDef(module)
 	dictionaryReplacementStatements: dict[ast_Identifier, ast.stmt | list[ast.stmt]] = {}
 	for name, astFunctionDef in dictionaryFunctionDef.items():
 		if ifThis.onlyReturnAnyCompare(astFunctionDef):
-			dictionaryReplacementStatements[name] = astFunctionDef.body[0].value
+			dictionaryReplacementStatements[name] = astFunctionDef.body[0].value # type: ignore
 		elif ifThis.onlyReturnUnaryOp(astFunctionDef):
-			dictionaryReplacementStatements[name] = astFunctionDef.body[0].value
+			dictionaryReplacementStatements[name] = astFunctionDef.body[0].value # type: ignore
 		else:
 			dictionaryReplacementStatements[name] = astFunctionDef.body[0:-1]
 	return dictionaryReplacementStatements
@@ -128,17 +341,17 @@ def Z0Z_inlineThisFunctionWithTheseValues(astFunctionDef: ast.FunctionDef, dicti
 
 		def visit_Expr(self, node: ast.Expr) -> ast.AST | list[ast.stmt]:
 			if ifThis.CallDoesNotCallItselfAndNameDOTidIsIn(self.dictionaryReplacementStatements)(node.value):
-				return self.dictionaryReplacementStatements[node.value.func.id]
+				return self.dictionaryReplacementStatements[node.value.func.id] # type: ignore
 			return node
 
 		def visit_Assign(self, node: ast.Assign) -> ast.AST | list[ast.stmt]:
 			if ifThis.CallDoesNotCallItselfAndNameDOTidIsIn(self.dictionaryReplacementStatements)(node.value):
-				return self.dictionaryReplacementStatements[node.value.func.id]
+				return self.dictionaryReplacementStatements[node.value.func.id] # type: ignore
 			return node
 
 		def visit_Call(self, node: ast.Call) -> ast.AST | list[ast.stmt]:
 			if ifThis.CallDoesNotCallItselfAndNameDOTidIsIn(self.dictionaryReplacementStatements)(node):
-				replacement = self.dictionaryReplacementStatements[node.func.id]
+				replacement = self.dictionaryReplacementStatements[node.func.id] # type: ignore
 				if not isinstance(replacement, list):
 					return replacement
 			return node

mapFolding/theSSOT.py

@@ -19,11 +19,11 @@ to avoid namespace collisions when transforming algorithms.
 from collections.abc import Callable
 from importlib import import_module as importlib_import_module
 from inspect import getfile as inspect_getfile
-from numpy import dtype, int64 as numpy_int64, int16 as numpy_int16, ndarray
+from numpy import dtype, int64 as numpy_int64, int16 as numpy_int16, integer, ndarray
 from pathlib import Path
 from tomli import load as tomli_load
 from types import ModuleType
-from typing import TypeAlias
+from typing import Any, TypeAlias, TypeVar
 import dataclasses
 
 # =============================================================================
@@ -55,7 +55,8 @@ concurrencyPackageHARDCODED = 'multiprocessing'
 # The following is an improvement, but it is not the full solution.
 # I hope that the standardized markers, `metadata={'evaluateWhen': 'packaging'}` will help to automate
 # whatever needs to happen so that the following is well implemented.
-@dataclasses.dataclass(frozen=True)
+# @dataclasses.dataclass(frozen=True)
+@dataclasses.dataclass
 class PackageSettings:
 
 	logicalPathModuleDispatcher: str | None = None
@@ -78,25 +79,14 @@ class PackageSettings:
 	sourceConcurrencyManagerNamespace: str = dataclasses.field(default='concurrencyManager', metadata={'evaluateWhen': 'packaging'})
 	sourceConcurrencyPackage: str = dataclasses.field(default='multiprocessing', metadata={'evaluateWhen': 'packaging'})
 
-	@property # These are not fields, and that annoys me.
-	def dataclassInstanceTaskDistribution(self) -> str:
-		""" During parallel computation, this identifier helps to create deep copies of the dataclass instance. """
-		# it follows that `metadata={'evaluateWhen': 'packaging'}`
-		return self.dataclassInstance + self.dataclassInstanceTaskDistributionSuffix
-
-	@property # These are not fields, and that annoys me.
-	def logicalPathModuleDataclass(self) -> str:
-		""" The package.module.name logical path to the dataclass. """
-		# it follows that `metadata={'evaluateWhen': 'packaging'}`
-		return '.'.join([self.packageName, self.dataclassModule])
-
-	@property # These are not fields, and that annoys me.
-	def logicalPathModuleSourceAlgorithm(self) -> str:
-		""" The package.module.name logical path to the source algorithm. """
-		# it follows that `metadata={'evaluateWhen': 'packaging'}`
-		return '.'.join([self.packageName, self.sourceAlgorithm])
-
-	@property # These are not fields, and that annoys me.
+	dataclassInstanceTaskDistribution: str = dataclasses.field(init=False, metadata={'evaluateWhen': 'packaging'})
+	""" During parallel computation, this identifier helps to create deep copies of the dataclass instance. """
+	logicalPathModuleDataclass: str = dataclasses.field(init=False)
+	""" The package.module.name logical path to the dataclass. """
+	logicalPathModuleSourceAlgorithm: str = dataclasses.field(init=False)
+	""" The package.module.name logical path to the source algorithm. """
+
+	@property # This is not a field, and that annoys me.
 	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
@@ -104,6 +94,12 @@ class PackageSettings:
 		moduleImported: ModuleType = importlib_import_module(logicalPath)
 		return getattr(moduleImported, identifier)
 
+	def __post_init__(self) -> None:
+		self.dataclassInstanceTaskDistribution = self.dataclassInstance + self.dataclassInstanceTaskDistributionSuffix
+
+		self.logicalPathModuleDataclass = '.'.join([self.packageName, self.dataclassModule])
+		self.logicalPathModuleSourceAlgorithm = '.'.join([self.packageName, self.sourceAlgorithm])
+
 The = PackageSettings(logicalPathModuleDispatcher=logicalPathModuleDispatcherHARDCODED, callableDispatcher=callableDispatcherHARDCODED, concurrencyPackage=concurrencyPackageHARDCODED)
 
 # To remove this function, I need to learn how to change "conftest.py" to patch this.
@@ -118,6 +114,8 @@ def getPackageDispatcher() -> Callable[['ComputationState'], 'ComputationState']
 # Flexible Data Structure System Needs Enhanced Paradigm https://github.com/hunterhogan/mapFolding/issues/9
 # Efficient translation of Python scalar types to Numba types https://github.com/hunterhogan/mapFolding/issues/8
 
+numpyIntegerType = TypeVar('numpyIntegerType', bound=integer[Any], covariant=True)
+
 DatatypeLeavesTotal: TypeAlias = int
 NumPyLeavesTotal: TypeAlias = numpy_int16 # this would be uint8, but mapShape (2,2,2,2, 2,2,2,2) has 256 leaves, so generic containers must accommodate at least 256 leaves
 
@@ -139,7 +137,7 @@ class ComputationState:
 	taskDivisions: DatatypeLeavesTotal
 	concurrencyLimit: DatatypeElephino
 
-	connectionGraph: Array3D = dataclasses.field(init=False, metadata={'dtype': Array3D.__args__[1].__args__[0]}) # pyright: ignore[reportAttributeAccessIssue]
+	connectionGraph: Array3D = dataclasses.field(init=False, metadata={'dtype': Array3D.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
 	dimensionsTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
 
 	countDimensionsGapped: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # type: ignore[arg-type, reportAssignmentType]
@@ -162,24 +160,24 @@ class ComputationState:
 	taskIndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
 
 	def __post_init__(self) -> None:
-		from mapFolding.beDRY import makeConnectionGraph, makeDataContainer
+		from mapFolding.beDRY import getConnectionGraph, makeDataContainer
 		self.dimensionsTotal = DatatypeLeavesTotal(len(self.mapShape))
 		leavesTotalAsInt = int(self.leavesTotal)
-		self.connectionGraph = makeConnectionGraph(self.mapShape, leavesTotalAsInt, self.__dataclass_fields__['connectionGraph'].metadata['dtype'])
+		self.connectionGraph = getConnectionGraph(self.mapShape, leavesTotalAsInt, self.__dataclass_fields__['connectionGraph'].metadata['dtype'])
 
-		if self.dimensionsUnconstrained is None:
+		if self.dimensionsUnconstrained is None: # type: ignore
 			self.dimensionsUnconstrained = DatatypeLeavesTotal(int(self.dimensionsTotal))
 
-		if self.foldGroups is None:
+		if self.foldGroups is None: # type: ignore
 			self.foldGroups = makeDataContainer(max(2, int(self.taskDivisions) + 1), self.__dataclass_fields__['foldGroups'].metadata['dtype'])
 			self.foldGroups[-1] = self.leavesTotal
 
-		if self.gapsWhere is None: self.gapsWhere = makeDataContainer(leavesTotalAsInt * leavesTotalAsInt + 1, self.__dataclass_fields__['gapsWhere'].metadata['dtype'])
+		if self.gapsWhere is None: self.gapsWhere = makeDataContainer(leavesTotalAsInt * leavesTotalAsInt + 1, self.__dataclass_fields__['gapsWhere'].metadata['dtype']) # type: ignore
 
-		if self.countDimensionsGapped is None: self.countDimensionsGapped = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['countDimensionsGapped'].metadata['dtype'])
-		if self.gapRangeStart is None: self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['gapRangeStart'].metadata['dtype'])
-		if self.leafAbove is None: self.leafAbove = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafAbove'].metadata['dtype'])
-		if self.leafBelow is None: self.leafBelow = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafBelow'].metadata['dtype'])
+		if self.countDimensionsGapped is None: self.countDimensionsGapped = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['countDimensionsGapped'].metadata['dtype']) # type: ignore
+		if self.gapRangeStart is None: self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['gapRangeStart'].metadata['dtype']) # type: ignore
+		if self.leafAbove is None: self.leafAbove = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafAbove'].metadata['dtype']) # type: ignore
+		if self.leafBelow is None: self.leafBelow = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafBelow'].metadata['dtype']) # type: ignore
 
 	def getFoldsTotal(self) -> None:
 		self.foldsTotal = DatatypeFoldsTotal(self.foldGroups[0:-1].sum() * self.leavesTotal)