mapFolding 0.8.1__py3-none-any.whl → 0.8.3__py3-none-any.whl

mapFolding/someAssemblyRequired/transformDataStructures.py

@@ -21,7 +21,7 @@ designed to be applicable to various data structure transformation scenarios.
 """
 
 from collections.abc import Sequence
-from importlib import import_module
+from importlib import import_module as importlib_import_module
 from inspect import getsource as inspect_getsource
 from mapFolding.beDRY import outfitCountFolds, validateListDimensions
 from mapFolding.filesystem import getPathFilenameFoldsTotal
@@ -36,7 +36,7 @@ from mapFolding.someAssemblyRequired import (
 	Then,
 	Z0Z_executeActionUnlessDescendantMatches,
 )
-from mapFolding.theSSOT import ComputationState, getSourceAlgorithm
+from mapFolding.theSSOT import ComputationState, The
 from pathlib import Path
 from types import ModuleType
 from typing import Any, Literal, overload
@@ -69,10 +69,12 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: strDotStrCuzPyStoopid, da
 		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.
 	"""
-	module: ast.Module = ast.parse(inspect_getsource(import_module(logicalPathModule)))
+	# TODO learn whether dataclasses.make_dataclass would be useful to transform the target dataclass into the `ShatteredDataclass`
+
+	module: ast.Module = ast.parse(inspect_getsource(importlib_import_module(logicalPathModule)))
 	astName_dataclassesDOTdataclass = Make.astName(dataclass_Identifier)
 
-	dataclass = extractClassDef(dataclass_Identifier, module)
+	dataclass = extractClassDef(module, dataclass_Identifier)
 	if not isinstance(dataclass, ast.ClassDef):
 		raise ValueError(f"I could not find {dataclass_Identifier=} in {logicalPathModule=}.")
 
@@ -122,6 +124,10 @@ def shatter_dataclassesDOTdataclass(logicalPathModule: strDotStrCuzPyStoopid, da
 	shatteredDataclass.ledgerDataclassANDFragments.addImportFromStr(logicalPathModule, dataclass_Identifier)
 	return shatteredDataclass
 
+def getSourceAlgorithmVESTIGIAL() -> ModuleType:
+	moduleImported: ModuleType = importlib_import_module(The.logicalPathModuleSourceAlgorithm)
+	return moduleImported
+
 @overload
 def makeStateJobOUTDATED(listDimensions: Sequence[int], *, writeJob: Literal[True], **keywordArguments: Any) -> Path: ...
 @overload
@@ -145,7 +151,7 @@ def makeStateJobOUTDATED(listDimensions: Sequence[int], *, writeJob: bool = True
 	mapShape = validateListDimensions(listDimensions)
 	stateUniversal: ComputationState = outfitCountFolds(mapShape, **keywordArguments)
 
-	moduleSource: ModuleType = getSourceAlgorithm()
+	moduleSource: ModuleType = getSourceAlgorithmVESTIGIAL()
 	# TODO `countInitialize` is hardcoded
 	stateUniversal = moduleSource.countInitialize(stateUniversal)
 

mapFolding/someAssemblyRequired/transformationTools.py

@@ -26,27 +26,16 @@ from autoflake import fix_code as autoflake_fix_code
 from collections import defaultdict
 from collections.abc import Callable, Container, Sequence
 from copy import deepcopy
+from importlib import import_module as importlib_import_module
 from inspect import getsource as inspect_getsource
 from mapFolding.filesystem import writeStringToHere
 from mapFolding.theSSOT import (
-	getSourceAlgorithm,
 	raiseIfNoneGitHubIssueNumber3,
-	theDataclassIdentifier,
-	theDataclassInstance,
-	theDataclassInstanceTaskDistribution,
-	theDispatcherCallable,
-	theFileExtension,
+	The,
 	theFormatStrModuleForCallableSynthetic,
 	theFormatStrModuleSynthetic,
-	theLogicalPathModuleDataclass,
 	theLogicalPathModuleDispatcherSynthetic,
 	theModuleDispatcherSynthetic,
-	theModuleOfSyntheticModules,
-	thePackageName,
-	thePathPackage,
-	theSourceInitializeCallable,
-	theSourceParallelCallable,
-	theSourceSequentialCallable,
 )
 from os import PathLike
 from pathlib import Path, PurePath, PurePosixPath
@@ -200,7 +189,8 @@ class ifThis:
 		return isinstance(node, ast.Call)
 	@staticmethod
 	def isCall_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Call] | bool]:
-		return lambda node: ifThis.isCall(node) and ifThis.isName_Identifier(identifier)(node.func)
+		def workhorse(node: ast.AST) -> TypeGuard[ast.Call] | bool: return ifThis.isCall(node) and ifThis.isName_Identifier(identifier)(node.func)
+		return workhorse
 	@staticmethod
 	def isCallNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Call] | bool]:
 		return lambda node: ifThis.isCall(node) and ifThis.is_nameDOTnameNamespace_Identifier(namespace, identifier)(node.func)
@@ -226,8 +216,7 @@ class ifThis:
 	def isExpr(node: ast.AST) -> TypeGuard[ast.Expr]:
 		return isinstance(node, ast.Expr)
 	@staticmethod
-	def isFunctionDef(node: ast.AST) -> TypeGuard[ast.FunctionDef]:
-		return isinstance(node, ast.FunctionDef)
+	def isFunctionDef(node: ast.AST) -> TypeGuard[ast.FunctionDef]: return isinstance(node, ast.FunctionDef)
 	@staticmethod
 	def isFunctionDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.FunctionDef] | bool]:
 		return lambda node: ifThis.isFunctionDef(node) and node.name == identifier
@@ -277,9 +266,9 @@ class ifThis:
 		Parameters:
 			identifier: The identifier to look for in the value chain
 		Returns:
-			predicate: function that checks if a node matches the criteria
+			workhorse: function that checks if a node matches the criteria
 		"""
-		def predicate(node: ast.AST) -> TypeGuard[ast.Subscript]:
+		def workhorse(node: ast.AST) -> TypeGuard[ast.Subscript]:
 			if not ifThis.isSubscript(node):
 				return False
 			def checkNodeDOTvalue(nodeDOTvalue: ast.AST) -> bool:
@@ -290,7 +279,7 @@ class ifThis:
 					return checkNodeDOTvalue(nodeDOTvalue.value) # type: ignore
 				return False
 			return checkNodeDOTvalue(node.value)
-		return predicate
+		return workhorse
 	@staticmethod
 	def isSubscriptIsName_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Subscript] | bool]:
 		return lambda node: ifThis.isSubscript(node) and ifThis.isName_Identifier(identifier)(node.value)
@@ -320,12 +309,12 @@ class ifThis:
 	@staticmethod
 	def matchesNoDescendant(predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], bool]:
 		"""Create a predicate that returns True if no descendant of the node matches the given predicate."""
-		def checkNoMatchingDescendant(node: ast.AST) -> bool:
+		def workhorse(node: ast.AST) -> bool:
 			for descendant in ast.walk(node):
 				if descendant is not node and predicate(descendant):
 					return False
 			return True
-		return checkNoMatchingDescendant
+		return workhorse
 	@staticmethod
 	def onlyReturnAnyCompare(astFunctionDef: ast.AST) -> TypeGuard[ast.FunctionDef]:
 		return ifThis.isFunctionDef(astFunctionDef) and len(astFunctionDef.body) == 1 and ifThis.isReturnAnyCompare(astFunctionDef.body[0])
@@ -487,11 +476,15 @@ class Then:
 	def insertThisBelow(list_astAST: Sequence[ast.AST]) -> Callable[[ast.AST], Sequence[ast.AST]]:
 		return lambda belowMe: [belowMe, *list_astAST]
 	@staticmethod
-	def removeThis(_node: ast.AST) -> None:
-		return None
+	def removeThis(_node: ast.AST) -> None: return None
+	@staticmethod
+	def replaceWith(astAST: ast.AST) -> Callable[[ast.AST], ast.AST]: return lambda _replaceMe: astAST
 	@staticmethod
-	def replaceWith(astAST: ast.AST) -> Callable[[ast.AST], ast.AST]:
-		return lambda _replaceMe: astAST
+	def replaceDOTfuncWith(ast_expr: ast.expr) -> Callable[[ast.Call], ast.Call]:
+		def workhorse(node: ast.Call) -> ast.Call:
+			node.func = ast_expr
+			return node
+		return workhorse
 	@staticmethod
 	def updateThis(dictionaryOf_astMosDef: dict[ast_Identifier, astMosDef]) -> Callable[[astMosDef], astMosDef]:
 		return lambda node: dictionaryOf_astMosDef.setdefault(node.name, node)
@@ -563,25 +556,27 @@ class RecipeSynthesizeFlow:
 	"""Settings for synthesizing flow."""
 	# ========================================
 	# Source
-	sourceAlgorithm: ModuleType = getSourceAlgorithm()
+	sourceAlgorithm: ModuleType = importlib_import_module(The.logicalPathModuleSourceAlgorithm)
 	sourcePython: str = inspect_getsource(sourceAlgorithm)
 	source_astModule: ast.Module = ast.parse(sourcePython)
 
 	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-	sourceDispatcherCallable: str = theDispatcherCallable
-	sourceInitializeCallable: str = theSourceInitializeCallable
-	sourceParallelCallable: str = theSourceParallelCallable
-	sourceSequentialCallable: str = theSourceSequentialCallable
-
-	sourceDataclassIdentifier: str = theDataclassIdentifier
-	sourceDataclassInstance: str = theDataclassInstance
-	sourceDataclassInstanceTaskDistribution: str = theDataclassInstanceTaskDistribution
-	sourcePathModuleDataclass: str = theLogicalPathModuleDataclass
-
+	sourceDispatcherCallable: str = The.dispatcherCallable
+	sourceInitializeCallable: str = The.sourceInitializeCallable
+	sourceParallelCallable: str = The.sourceParallelCallable
+	sourceSequentialCallable: str = The.sourceSequentialCallable
+
+	sourceDataclassIdentifier: str = The.dataclassIdentifier
+	sourceDataclassInstance: str = The.dataclassInstance
+	sourceDataclassInstanceTaskDistribution: str = The.dataclassInstanceTaskDistribution
+	sourcePathModuleDataclass: str = The.logicalPathModuleDataclass
+
+	sourceConcurrencyManagerNamespace = The.sourceConcurrencyManagerNamespace
+	sourceConcurrencyManagerIdentifier = The.sourceConcurrencyManagerIdentifier
 	# ========================================
 	# Filesystem
-	pathPackage: PurePosixPath | None = PurePosixPath(thePathPackage)
-	fileExtension: str = theFileExtension
+	pathPackage: PurePosixPath | None = PurePosixPath(The.pathPackage)
+	fileExtension: str = The.fileExtension
 
 	# ========================================
 	# Logical identifiers
@@ -590,11 +585,11 @@ class RecipeSynthesizeFlow:
 	formatStrModuleForCallableSynthetic: str = theFormatStrModuleForCallableSynthetic
 
 	# Package
-	packageName: ast_Identifier | None = thePackageName
+	packageName: ast_Identifier | None = The.packageName
 
 	# Module
 	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-	Z0Z_flowLogicalPathRoot: str = theModuleOfSyntheticModules
+	Z0Z_flowLogicalPathRoot: str | None = The.moduleOfSyntheticModules
 	moduleDispatcher: str = theModuleDispatcherSynthetic
 	logicalPathModuleDataclass: str = sourcePathModuleDataclass
 	# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
@@ -606,6 +601,9 @@ class RecipeSynthesizeFlow:
 	initializeCallable: str = sourceInitializeCallable
 	parallelCallable: str = sourceParallelCallable
 	sequentialCallable: str = sourceSequentialCallable
+	# initializeCallable: str = 'StartTheCommotion'
+	# parallelCallable: str = sourceParallelCallable
+	# sequentialCallable: str = sourceSequentialCallable
 
 	dataclassIdentifier: str = sourceDataclassIdentifier
 
@@ -632,14 +630,14 @@ class RecipeSynthesizeFlow:
 	def pathFilenameDispatcher(self) -> PurePosixPath:
 		return self._makePathFilename(filenameStem=self.moduleDispatcher, logicalPathINFIX=self.Z0Z_flowLogicalPathRoot)
 
-def extractClassDef(identifier: ast_Identifier, module: ast.Module) -> ast.ClassDef | None:
+def extractClassDef(module: ast.Module, identifier: ast_Identifier) -> ast.ClassDef | None:
 	sherpa: list[ast.ClassDef] = []
 	extractor = NodeCollector(ifThis.isClassDef_Identifier(identifier), [Then.appendTo(sherpa)])
 	extractor.visit(module)
 	astClassDef = sherpa[0] if sherpa else None
 	return astClassDef
 
-def extractFunctionDef(identifier: ast_Identifier, module: ast.Module) -> ast.FunctionDef | None:
+def extractFunctionDef(module: ast.Module, identifier: ast_Identifier) -> ast.FunctionDef | None:
 	sherpa: list[ast.FunctionDef] = []
 	extractor = NodeCollector(ifThis.isFunctionDef_Identifier(identifier), [Then.appendTo(sherpa)])
 	extractor.visit(module)

mapFolding/syntheticModules/__init__.py

@@ -0,0 +1 @@
+"""Everything in this directory is synthesized by other modules in the package."""

mapFolding/theSSOT.py

@@ -19,114 +19,85 @@ 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, signedinteger
+from numpy import dtype, int64 as numpy_int64, int16 as numpy_int16, ndarray
 from pathlib import Path
 from sys import modules as sysModules
 from tomli import load as tomli_load
 from types import ModuleType
-from typing import Any, Final, TypeAlias
+from typing import TypeAlias
 import dataclasses
 
-"""
-2025 March 11
-Note to self: fundamental concept in Python:
-Identifiers: scope and resolution, LEGB (Local, Enclosing, Global, Builtin)
-- Local: Inside the function
-- Enclosing: Inside enclosing functions
-- Global: At the uppermost level
-- Builtin: Python's built-in names
-"""
-
-# I _think_, in theSSOT, I have abstracted the flow settings to only these couple of lines:
 # Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
+# I _think_, in theSSOT, I have abstracted the flow settings to only these couple of lines:
 packageFlowSynthetic = 'numba'
 # Z0Z_packageFlow = 'algorithm'
 Z0Z_packageFlow = packageFlowSynthetic
 Z0Z_concurrencyPackage = 'multiprocessing'
-# =============================================================================
-# The Wrong Way The Wrong Way The Wrong Way The Wrong Way The Wrong Way
-# Evaluate When Packaging Evaluate When Packaging Evaluate When Packaging
-
-sourceAlgorithmPACKAGING: str = 'theDao'
-datatypePackagePACKAGING: Final[str] = 'numpy'
-dispatcherCallablePACKAGING: str = 'doTheNeedful'
-moduleOfSyntheticModulesPACKAGING: Final[str] = 'syntheticModules'
 
-dataclassModulePACKAGING: str = 'theSSOT'
-dataclassIdentifierPACKAGING: str = 'ComputationState'
-dataclassInstancePACKAGING: str = 'state'
-dataclassInstanceTaskDistributionPACKAGING = dataclassInstancePACKAGING + 'Parallel'
-
-sourceInitializeCallablePACKAGING = 'countInitialize'
-sourceSequentialCallablePACKAGING = 'countSequential'
-sourceParallelCallablePACKAGING = 'countParallel'
+# =============================================================================
+# The Wrong Way: Evaluate When Packaging
 
 try:
-	thePackageNamePACKAGING: str = tomli_load(Path("../pyproject.toml").open('rb'))["project"]["name"]
+	packageNamePACKAGING: str = tomli_load(Path("../pyproject.toml").open('rb'))["project"]["name"]
 except Exception:
-	thePackageNamePACKAGING = "mapFolding"
-
-# =============================================================================
-# The Wrong Way The Wrong Way The Wrong Way The Wrong Way The Wrong Way
-# Evaluate When Installing Evaluate When Installing Evaluate When Installing
+	packageNamePACKAGING = "mapFolding"
 
-fileExtensionINSTALLING: str = '.py'
+# The Wrong Way: Evaluate When Installing
 
 def getPathPackageINSTALLING() -> Path:
-	pathPackage: Path = Path(inspect_getfile(importlib_import_module(thePackageNamePACKAGING)))
+	pathPackage: Path = Path(inspect_getfile(importlib_import_module(packageNamePACKAGING)))
 	if pathPackage.is_file():
 		pathPackage = pathPackage.parent
 	return pathPackage
 
-# =============================================================================
-# The right way, perhaps.
-
-# Create enduring identifiers from the hopefully transient identifiers above.
-thePackageName: Final[str] = thePackageNamePACKAGING
-thePathPackage: Path = getPathPackageINSTALLING()
-
-"""
-NOTE on semiotics: `theIdentifier` vs `identifier`
-
-- This package has a typical, "hardcoded" algorithm for counting map folds.
-- This package has logic for transforming that algorithm into other forms.
-- The transformation logic can transform other algorithms if 1) they are similar enough to the "hardcoded" algorithm and 2) I have written the transformation logic well enough to handle the differences.
-- To avoid confusion and namespace collisions, I differentiate between, for example, `theSourceAlgorithm` of the package and any other `sourceAlgorithm` being transformed by the package.
-"""
-
-theSourceAlgorithm: str = sourceAlgorithmPACKAGING
-theSourceInitializeCallable = sourceInitializeCallablePACKAGING
-theSourceSequentialCallable = sourceSequentialCallablePACKAGING
-theSourceParallelCallable = sourceParallelCallablePACKAGING
-theDatatypePackage: Final[str] = datatypePackagePACKAGING
-
-theDispatcherCallable: str = dispatcherCallablePACKAGING
-
-theDataclassModule: str = dataclassModulePACKAGING
-theDataclassIdentifier: str = dataclassIdentifierPACKAGING
-theDataclassInstance: str = dataclassInstancePACKAGING
-theDataclassInstanceTaskDistribution: str = dataclassInstanceTaskDistributionPACKAGING
-
-theFileExtension: str = fileExtensionINSTALLING
-
-theModuleOfSyntheticModules: Final[str] = moduleOfSyntheticModulesPACKAGING
+# 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)
+class PackageSettings:
+	concurrencyPackage = Z0Z_concurrencyPackage
+	dataclassIdentifier: str = dataclasses.field(default='ComputationState', metadata={'evaluateWhen': 'packaging'})
+	dataclassInstance: str = dataclasses.field(default='state', metadata={'evaluateWhen': 'packaging'})
+	dataclassInstanceTaskDistributionSuffix: str = dataclasses.field(default='Parallel', metadata={'evaluateWhen': 'packaging'})
+	dataclassModule: str = dataclasses.field(default='theSSOT', metadata={'evaluateWhen': 'packaging'})
+	datatypePackage: str = dataclasses.field(default='numpy', metadata={'evaluateWhen': 'packaging'})
+	dispatcherCallable: str = dataclasses.field(default='doTheNeedful', metadata={'evaluateWhen': 'packaging'})
+	fileExtension: str = dataclasses.field(default='.py', metadata={'evaluateWhen': 'installing'})
+	moduleOfSyntheticModules: str = dataclasses.field(default='syntheticModules', metadata={'evaluateWhen': 'packaging'})
+	packageName: str = dataclasses.field(default = packageNamePACKAGING, metadata={'evaluateWhen': 'packaging'})
+	pathPackage: Path = dataclasses.field(default_factory=getPathPackageINSTALLING, init=False, metadata={'evaluateWhen': 'installing'})
+	sourceAlgorithm: str = dataclasses.field(default='theDao', metadata={'evaluateWhen': 'packaging'})
+	sourceConcurrencyManagerIdentifier: str = dataclasses.field(default='submit', metadata={'evaluateWhen': 'packaging'})
+	sourceConcurrencyManagerNamespace: str = dataclasses.field(default='concurrencyManager', metadata={'evaluateWhen': 'packaging'})
+	sourceInitializeCallable: str = dataclasses.field(default='countInitialize', metadata={'evaluateWhen': 'packaging'})
+	sourceParallelCallable: str = dataclasses.field(default='countParallel', metadata={'evaluateWhen': 'packaging'})
+	sourceSequentialCallable: str = dataclasses.field(default='countSequential', metadata={'evaluateWhen': 'packaging'})
+
+	@property # These are not fields, and that annoys me.
+	def dataclassInstanceTaskDistribution(self) -> str:
+		""" Compute the task distribution identifier by concatenating dataclassInstance and dataclassInstanceTaskDistributionSuffix. """
+		# it follows that `metadata={'evaluateWhen': 'packaging'}`
+		return self.dataclassInstance + self.dataclassInstanceTaskDistributionSuffix
+
+	@property # These are not fields, and that annoys me.
+	def logicalPathModuleSourceAlgorithm(self) -> str:
+		""" Compute the logical path module for the source algorithm by joining packageName and sourceAlgorithm. """
+		# it follows that `metadata={'evaluateWhen': 'packaging'}`
+		return '.'.join([self.packageName, self.sourceAlgorithm])
+
+	@property # These are not fields, and that annoys me.
+	def logicalPathModuleDataclass(self) -> str:
+		""" Compute the logical path module for the dataclass by joining packageName and dataclassModule. """
+		# it follows that `metadata={'evaluateWhen': 'packaging'}`
+		return '.'.join([self.packageName, self.dataclassModule])
+
+The = PackageSettings()
 
 # =============================================================================
-
-# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-concurrencyPackage: str = Z0Z_packageFlow
-concurrencyPackage = Z0Z_concurrencyPackage
-
-# =============================================================================
-# The relatively flexible type system needs a different paradigm, but I don't
-# know what it should be. The system needs to 1) help optimize computation, 2)
-# make it possible to change the basic type of the package (e.g., from numpy
-# to superTypePy), 3) make it possible to synthesize the optimized flow of used
-# by the package, and 4) make it possible to synthesize arbitrary modules with
-# different type systems.
+# Flexible Data Structure System Needs Enhanced Paradigm https://github.com/hunterhogan/mapFolding/issues/9
 
 DatatypeLeavesTotal: TypeAlias = int
-# this would be uint8, but mapShape (2,2,2,2, 2,2,2,2) has 256 leaves, so generic containers accommodate
+# 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
 numpyLeavesTotal: TypeAlias = numpy_int16
 
 DatatypeElephino: TypeAlias = int
@@ -134,18 +105,12 @@ numpyElephino: TypeAlias = numpy_int16
 
 DatatypeFoldsTotal: TypeAlias = int
 numpyFoldsTotal: TypeAlias = numpy_int64
-numpyDtypeDefault = numpyFoldsTotal
 
 Array3D: TypeAlias = ndarray[tuple[int, int, int], dtype[numpyLeavesTotal]]
 Array1DLeavesTotal: TypeAlias = ndarray[tuple[int], dtype[numpyLeavesTotal]]
 Array1DElephino: TypeAlias = ndarray[tuple[int], dtype[numpyElephino]]
 Array1DFoldsTotal: TypeAlias = ndarray[tuple[int], dtype[numpyFoldsTotal]]
 
-# =============================================================================
-# The right way.
-# (The dataclass, not the typing of the dataclass.)
-# (Also, my noobplementation of the dataclass certainly needs improvement.)
-
 @dataclasses.dataclass
 class ComputationState:
 	mapShape: tuple[DatatypeLeavesTotal, ...]
@@ -191,9 +156,9 @@ class ComputationState:
 		leavesTotalAsInt = int(self.leavesTotal)
 
 		if self.countDimensionsGapped is None:
-			self.countDimensionsGapped = makeDataContainer(leavesTotalAsInt + 1, numpyElephino)
+			self.countDimensionsGapped = makeDataContainer(leavesTotalAsInt + 1, numpyLeavesTotal)
 		if self.gapRangeStart is None:
-			self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, numpyLeavesTotal)
+			self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, numpyElephino)
 		if self.gapsWhere is None:
 			self.gapsWhere = makeDataContainer(leavesTotalAsInt * leavesTotalAsInt + 1, numpyLeavesTotal)
 		if self.leafAbove is None:
@@ -205,75 +170,43 @@ class ComputationState:
 		self.foldsTotal = DatatypeFoldsTotal(self.foldGroups[0:-1].sum() * self.leavesTotal)
 
 # =============================================================================
-# The most right way I know how to implement.
-
-theLogicalPathModuleSourceAlgorithm: str = '.'.join([thePackageName, theSourceAlgorithm])
-theLogicalPathModuleDispatcher: str = theLogicalPathModuleSourceAlgorithm
-theLogicalPathModuleDataclass: str = '.'.join([thePackageName, theDataclassModule])
-
-def getSourceAlgorithm() -> ModuleType:
-	moduleImported: ModuleType = importlib_import_module(theLogicalPathModuleSourceAlgorithm)
-	return moduleImported
-
-def getAlgorithmDispatcher() -> Callable[[ComputationState], ComputationState]:
-	moduleImported: ModuleType = getSourceAlgorithm()
-	dispatcherCallable = getattr(moduleImported, theDispatcherCallable)
-	return dispatcherCallable
-
-def getPathSyntheticModules() -> Path:
-	return thePathPackage / theModuleOfSyntheticModules
 
 # TODO learn how to see this from the user's perspective
 def getPathJobRootDEFAULT() -> Path:
 	if 'google.colab' in sysModules:
 		pathJobDEFAULT: Path = Path("/content/drive/MyDrive") / "jobs"
 	else:
-		pathJobDEFAULT = thePathPackage / "jobs"
+		pathJobDEFAULT = The.pathPackage / "jobs"
 	return pathJobDEFAULT
 
-_datatypePackage: str = ''
-def getDatatypePackage() -> str:
-	global _datatypePackage
-	if not _datatypePackage:
-		_datatypePackage = theDatatypePackage
-	return _datatypePackage
-
-def getNumpyDtypeDefault() -> type[signedinteger[Any]]:
-	return numpyDtypeDefault
-
 # =============================================================================
 # The coping way.
 
 class raiseIfNoneGitHubIssueNumber3(Exception): pass
 
 # =============================================================================
-# Temporary or transient or something; probably still the wrong way
-
 # THIS IS A STUPID SYSTEM BUT I CAN'T FIGURE OUT AN IMPROVEMENT
 # NOTE This section for _default_ values probably has value
 # https://github.com/hunterhogan/mapFolding/issues/4
 theFormatStrModuleSynthetic = "{packageFlow}Count"
 theFormatStrModuleForCallableSynthetic = theFormatStrModuleSynthetic + "_{callableTarget}"
 
-theModuleDispatcherSynthetic: str = theFormatStrModuleForCallableSynthetic.format(packageFlow=packageFlowSynthetic, callableTarget=theDispatcherCallable)
-theLogicalPathModuleDispatcherSynthetic: str = '.'.join([thePackageName, theModuleOfSyntheticModules, theModuleDispatcherSynthetic])
+theLogicalPathModuleDispatcher: str = The.logicalPathModuleSourceAlgorithm
 
-# =============================================================================
-# The most right way I know how to implement.
+theModuleDispatcherSynthetic: str = theFormatStrModuleForCallableSynthetic.format(packageFlow=packageFlowSynthetic, callableTarget=The.dispatcherCallable)
+theLogicalPathModuleDispatcherSynthetic: str = '.'.join([The.packageName, The.moduleOfSyntheticModules, theModuleDispatcherSynthetic])
 
-# https://github.com/hunterhogan/mapFolding/issues/4
 if Z0Z_packageFlow == packageFlowSynthetic: # pyright: ignore [reportUnnecessaryComparison]
 	# NOTE this as a default value _might_ have value
 	theLogicalPathModuleDispatcher = theLogicalPathModuleDispatcherSynthetic
 
-# https://github.com/hunterhogan/mapFolding/issues/4
 # dynamically set the return type https://github.com/hunterhogan/mapFolding/issues/5
 def getPackageDispatcher() -> Callable[[ComputationState], ComputationState]:
 	# NOTE but this part, if the package flow is synthetic, probably needs to be delegated
 	# to the authority for creating _that_ synthetic flow.
 
 	moduleImported: ModuleType = importlib_import_module(theLogicalPathModuleDispatcher)
-	dispatcherCallable = getattr(moduleImported, theDispatcherCallable)
+	dispatcherCallable = getattr(moduleImported, The.dispatcherCallable)
 	return dispatcherCallable
 
 """Technical concepts I am likely using and likely want to use more effectively:
@@ -288,4 +221,13 @@ theSSOT and yourSSOT
 ----
 delay realization/instantiation until a concrete value is desired
 moment of truth: when the value is needed, not when the value is defined
+
+----
+2025 March 11
+Note to self: fundamental concept in Python:
+Identifiers: scope and resolution, LEGB (Local, Enclosing, Global, Builtin)
+- Local: Inside the function
+- Enclosing: Inside enclosing functions
+- Global: At the uppermost level
+- Builtin: Python's built-in names
 """