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

mapFolding/syntheticModules/numbaCount_doTheNeedful.py

@@ -2,6 +2,7 @@ from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
 from copy import deepcopy
 from mapFolding.theSSOT import Array1DElephino, Array1DFoldsTotal, Array1DLeavesTotal, Array3D, ComputationState, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
 from numba import jit
+from numpy import array, int16, int64
 
 def countInitialize(state: ComputationState) -> ComputationState:
     while state.leaf1ndex > 0:
@@ -22,11 +23,11 @@ def countInitialize(state: ComputationState) -> ComputationState:
                         state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
                 state.indexDimension += 1
             if not state.dimensionsUnconstrained:
-                indexLeaf = 0
-                while indexLeaf < state.leaf1ndex:
-                    state.gapsWhere[state.gap1ndexCeiling] = indexLeaf
+                state.indexLeaf = 0
+                while state.indexLeaf < state.leaf1ndex:
+                    state.gapsWhere[state.gap1ndexCeiling] = state.indexLeaf
                     state.gap1ndexCeiling += 1
-                    indexLeaf += 1
+                    state.indexLeaf += 1
             state.indexMiniGap = state.gap1ndex
             while state.indexMiniGap < state.gap1ndexCeiling:
                 state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
@@ -139,36 +140,38 @@ def doTheNeedful(state: ComputationState) -> ComputationState:
     state = countInitialize(state)
     if state.taskDivisions > 0:
         dictionaryConcurrency: dict[int, ConcurrentFuture[ComputationState]] = {}
-        with ProcessPoolExecutor(state.concurrencyLimit) as concurrencyManager:
-            for indexSherpa in range(state.taskDivisions):
-                stateParallel = deepcopy(state)
-                stateParallel.taskIndex = indexSherpa
-                mapShape: tuple[DatatypeLeavesTotal, ...] = stateParallel.mapShape
-                leavesTotal: DatatypeLeavesTotal = stateParallel.leavesTotal
-                taskDivisions: DatatypeLeavesTotal = stateParallel.taskDivisions
-                concurrencyLimit: DatatypeElephino = stateParallel.concurrencyLimit
-                connectionGraph: Array3D = stateParallel.connectionGraph
-                dimensionsTotal: DatatypeLeavesTotal = stateParallel.dimensionsTotal
-                countDimensionsGapped: Array1DLeavesTotal = stateParallel.countDimensionsGapped
-                dimensionsUnconstrained: DatatypeLeavesTotal = stateParallel.dimensionsUnconstrained
-                gapRangeStart: Array1DElephino = stateParallel.gapRangeStart
-                gapsWhere: Array1DLeavesTotal = stateParallel.gapsWhere
-                leafAbove: Array1DLeavesTotal = stateParallel.leafAbove
-                leafBelow: Array1DLeavesTotal = stateParallel.leafBelow
-                foldGroups: Array1DFoldsTotal = stateParallel.foldGroups
-                foldsTotal: DatatypeFoldsTotal = stateParallel.foldsTotal
-                gap1ndex: DatatypeLeavesTotal = stateParallel.gap1ndex
-                gap1ndexCeiling: DatatypeElephino = stateParallel.gap1ndexCeiling
-                groupsOfFolds: DatatypeFoldsTotal = stateParallel.groupsOfFolds
-                indexDimension: DatatypeLeavesTotal = stateParallel.indexDimension
-                indexLeaf: DatatypeLeavesTotal = stateParallel.indexLeaf
-                indexMiniGap: DatatypeElephino = stateParallel.indexMiniGap
-                leaf1ndex: DatatypeElephino = stateParallel.leaf1ndex
-                leafConnectee: DatatypeElephino = stateParallel.leafConnectee
-                taskIndex: DatatypeLeavesTotal = stateParallel.taskIndex
+        stateParallel = deepcopy(state)
+        with ProcessPoolExecutor(stateParallel.concurrencyLimit) as concurrencyManager:
+            for indexSherpa in range(stateParallel.taskDivisions):
+                state = deepcopy(stateParallel)
+                state.taskIndex = indexSherpa
+                mapShape: tuple[DatatypeLeavesTotal, ...] = state.mapShape
+                leavesTotal: DatatypeLeavesTotal = state.leavesTotal
+                taskDivisions: DatatypeLeavesTotal = state.taskDivisions
+                concurrencyLimit: DatatypeElephino = state.concurrencyLimit
+                connectionGraph: Array3D = state.connectionGraph
+                dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
+                countDimensionsGapped: Array1DLeavesTotal = state.countDimensionsGapped
+                dimensionsUnconstrained: DatatypeLeavesTotal = state.dimensionsUnconstrained
+                gapRangeStart: Array1DElephino = state.gapRangeStart
+                gapsWhere: Array1DLeavesTotal = state.gapsWhere
+                leafAbove: Array1DLeavesTotal = state.leafAbove
+                leafBelow: Array1DLeavesTotal = state.leafBelow
+                foldGroups: Array1DFoldsTotal = state.foldGroups
+                foldsTotal: DatatypeFoldsTotal = state.foldsTotal
+                gap1ndex: DatatypeLeavesTotal = state.gap1ndex
+                gap1ndexCeiling: DatatypeElephino = state.gap1ndexCeiling
+                groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
+                indexDimension: DatatypeLeavesTotal = state.indexDimension
+                indexLeaf: DatatypeLeavesTotal = state.indexLeaf
+                indexMiniGap: DatatypeElephino = state.indexMiniGap
+                leaf1ndex: DatatypeElephino = state.leaf1ndex
+                leafConnectee: DatatypeElephino = state.leafConnectee
+                taskIndex: DatatypeLeavesTotal = state.taskIndex
                 dictionaryConcurrency[indexSherpa] = concurrencyManager.submit(countParallel, mapShape, leavesTotal, taskDivisions, concurrencyLimit, connectionGraph, dimensionsTotal, countDimensionsGapped, dimensionsUnconstrained, gapRangeStart, gapsWhere, leafAbove, leafBelow, foldGroups, foldsTotal, gap1ndex, gap1ndexCeiling, groupsOfFolds, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, taskIndex)
-            for indexSherpa in range(state.taskDivisions):
-                state.foldGroups[indexSherpa] = dictionaryConcurrency[indexSherpa].result()
+            for indexSherpa in range(stateParallel.taskDivisions):
+                stateParallel.foldGroups[indexSherpa] = dictionaryConcurrency[indexSherpa].result()
+        state = stateParallel
     else:
         mapShape: tuple[DatatypeLeavesTotal, ...] = state.mapShape
         leavesTotal: DatatypeLeavesTotal = state.leavesTotal

mapFolding/theDao.py

@@ -101,11 +101,11 @@ def initializeVariablesToFindGaps(state: ComputationState) -> ComputationState:
 	return state
 
 def insertUnconstrainedLeaf(state: ComputationState) -> ComputationState:
-	indexLeaf = 0
-	while indexLeaf < state.leaf1ndex:
-		state.gapsWhere[state.gap1ndexCeiling] = indexLeaf
+	state.indexLeaf = 0
+	while state.indexLeaf < state.leaf1ndex:
+		state.gapsWhere[state.gap1ndexCeiling] = state.indexLeaf
 		state.gap1ndexCeiling += 1
-		indexLeaf += 1
+		state.indexLeaf += 1
 	return state
 
 def leafBelowSentinelIs1(state: ComputationState) -> bool:
@@ -227,13 +227,15 @@ def doTheNeedful(state: ComputationState) -> ComputationState:
 	state = countInitialize(state)
 	if state.taskDivisions > 0:
 		dictionaryConcurrency: dict[int, ConcurrentFuture[ComputationState]] = {}
-		with ProcessPoolExecutor(state.concurrencyLimit) as concurrencyManager:
-			for indexSherpa in range(state.taskDivisions):
-				stateParallel = deepcopy(state)
-				stateParallel.taskIndex = indexSherpa
-				dictionaryConcurrency[indexSherpa] = concurrencyManager.submit(countParallel, stateParallel)
-			for indexSherpa in range(state.taskDivisions):
-				state.foldGroups[indexSherpa] = dictionaryConcurrency[indexSherpa].result().foldGroups[indexSherpa]
+		stateParallel = deepcopy(state)
+		with ProcessPoolExecutor(stateParallel.concurrencyLimit) as concurrencyManager:
+			for indexSherpa in range(stateParallel.taskDivisions):
+				state = deepcopy(stateParallel)
+				state.taskIndex = indexSherpa
+				dictionaryConcurrency[indexSherpa] = concurrencyManager.submit(countParallel, state)
+			for indexSherpa in range(stateParallel.taskDivisions):
+				stateParallel.foldGroups[indexSherpa] = dictionaryConcurrency[indexSherpa].result().foldGroups[indexSherpa]
+		state = stateParallel
 	else:
 		state = countSequential(state)
 

mapFolding/theSSOT.py

@@ -21,19 +21,11 @@ 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 pathlib import Path
-from sys import modules as sysModules
 from tomli import load as tomli_load
 from types import ModuleType
 from typing import TypeAlias
 import dataclasses
 
-# 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: Evaluate When Packaging
 
@@ -50,84 +42,113 @@ def getPathPackageINSTALLING() -> Path:
 		pathPackage = pathPackage.parent
 	return pathPackage
 
+# =============================================================================
+# The Wrong Way: HARDCODED
+# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
+
+# from mapFolding.someAssemblyRequired.synthesizeNumbaFlow.theNumbaFlow
+logicalPathModuleDispatcherHARDCODED: str = 'mapFolding.syntheticModules.numbaCount_doTheNeedful'
+callableDispatcherHARDCODED: str = 'doTheNeedful'
+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)
 class PackageSettings:
-	concurrencyPackage = Z0Z_concurrencyPackage
+
+	logicalPathModuleDispatcher: str | None = None
+	callableDispatcher: str | None = None
+	concurrencyPackage: str |None = None
 	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'})
+	sourceCallableDispatcher: str = dataclasses.field(default='doTheNeedful', metadata={'evaluateWhen': 'packaging'})
+	sourceCallableInitialize: str = dataclasses.field(default='countInitialize', metadata={'evaluateWhen': 'packaging'})
+	sourceCallableParallel: str = dataclasses.field(default='countParallel', metadata={'evaluateWhen': 'packaging'})
+	sourceCallableSequential: str = dataclasses.field(default='countSequential', 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'})
+	sourceConcurrencyPackage: str = dataclasses.field(default='multiprocessing', 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. """
+		""" 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 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. """
+		""" The package.module.name logical path to the dataclass. """
 		# it follows that `metadata={'evaluateWhen': 'packaging'}`
 		return '.'.join([self.packageName, self.dataclassModule])
 
-The = PackageSettings()
+	@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.
+	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)
+
+The = PackageSettings(logicalPathModuleDispatcher=logicalPathModuleDispatcherHARDCODED, callableDispatcher=callableDispatcherHARDCODED, concurrencyPackage=concurrencyPackageHARDCODED)
+
+# To remove this function, I need to learn how to change "conftest.py" to patch this.
+def getPackageDispatcher() -> Callable[['ComputationState'], 'ComputationState']:
+	"""Get the dispatcher callable for the package.
+
+	This function retrieves the dispatcher callable for the package based on the
+	logical path module and callable dispatcher defined in the PackageSettings.
+	"""
+	return The.dispatcher
 # =============================================================================
 # 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
 
 DatatypeLeavesTotal: TypeAlias = int
-# 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
+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
 
 DatatypeElephino: TypeAlias = int
-numpyElephino: TypeAlias = numpy_int16
+NumPyElephino: TypeAlias = numpy_int16
 
 DatatypeFoldsTotal: TypeAlias = int
-numpyFoldsTotal: TypeAlias = numpy_int64
+NumPyFoldsTotal: TypeAlias = numpy_int64
 
-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]]
+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]]
 
 @dataclasses.dataclass
 class ComputationState:
-	mapShape: tuple[DatatypeLeavesTotal, ...]
+	mapShape: tuple[DatatypeLeavesTotal, ...] = dataclasses.field(init=True, metadata={'elementConstructor': 'DatatypeLeavesTotal'}) # NOTE Python is anti-DRY, again, `DatatypeLeavesTotal` needs to match the type
 	leavesTotal: DatatypeLeavesTotal
 	taskDivisions: DatatypeLeavesTotal
 	concurrencyLimit: DatatypeElephino
 
-	connectionGraph: Array3D = dataclasses.field(init=False)
+	connectionGraph: Array3D = dataclasses.field(init=False, metadata={'dtype': Array3D.__args__[1].__args__[0]}) # pyright: ignore[reportAttributeAccessIssue]
 	dimensionsTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
 
-	countDimensionsGapped: Array1DLeavesTotal = dataclasses.field(default=None, init=True) # type: ignore[arg-type, reportAssignmentType]
+	countDimensionsGapped: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # type: ignore[arg-type, reportAssignmentType]
 	dimensionsUnconstrained: DatatypeLeavesTotal = dataclasses.field(default=None, init=True) # type: ignore[assignment, reportAssignmentType]
-	gapRangeStart: Array1DElephino = dataclasses.field(default=None, init=True) # type: ignore[arg-type, reportAssignmentType]
-	gapsWhere: Array1DLeavesTotal = dataclasses.field(default=None, init=True) # type: ignore[arg-type, reportAssignmentType]
-	leafAbove: Array1DLeavesTotal = dataclasses.field(default=None, init=True) # type: ignore[arg-type, reportAssignmentType]
-	leafBelow: Array1DLeavesTotal = dataclasses.field(default=None, init=True) # type: ignore[arg-type, reportAssignmentType]
-	foldGroups: Array1DFoldsTotal = dataclasses.field(default=None, init=True) # type: ignore[arg-type, reportAssignmentType]
+	gapRangeStart: Array1DElephino = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DElephino.__args__[1].__args__[0]}) # type: ignore[arg-type, reportAssignmentType]
+	gapsWhere: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # type: ignore[arg-type, reportAssignmentType]
+	leafAbove: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # type: ignore[arg-type, reportAssignmentType]
+	leafBelow: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # type: ignore[arg-type, reportAssignmentType]
+	foldGroups: Array1DFoldsTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DFoldsTotal.__args__[1].__args__[0]}) # type: ignore[arg-type, reportAssignmentType]
 
 	foldsTotal: DatatypeFoldsTotal = DatatypeFoldsTotal(0)
 	gap1ndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
@@ -139,95 +160,31 @@ class ComputationState:
 	leaf1ndex: DatatypeElephino = DatatypeElephino(1)
 	leafConnectee: DatatypeElephino = DatatypeElephino(0)
 	taskIndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
-	# Efficient translation of Python scalar types to Numba types https://github.com/hunterhogan/mapFolding/issues/8
 
 	def __post_init__(self) -> None:
 		from mapFolding.beDRY import makeConnectionGraph, makeDataContainer
 		self.dimensionsTotal = DatatypeLeavesTotal(len(self.mapShape))
-		self.connectionGraph = makeConnectionGraph(self.mapShape, self.leavesTotal, numpyLeavesTotal)
+		leavesTotalAsInt = int(self.leavesTotal)
+		self.connectionGraph = makeConnectionGraph(self.mapShape, leavesTotalAsInt, self.__dataclass_fields__['connectionGraph'].metadata['dtype'])
 
-		if self.dimensionsUnconstrained is None: # pyright: ignore[reportUnnecessaryComparison]
+		if self.dimensionsUnconstrained is None:
 			self.dimensionsUnconstrained = DatatypeLeavesTotal(int(self.dimensionsTotal))
 
 		if self.foldGroups is None:
-			self.foldGroups = makeDataContainer(max(2, int(self.taskDivisions) + 1), numpyFoldsTotal)
+			self.foldGroups = makeDataContainer(max(2, int(self.taskDivisions) + 1), self.__dataclass_fields__['foldGroups'].metadata['dtype'])
 			self.foldGroups[-1] = self.leavesTotal
 
-		leavesTotalAsInt = int(self.leavesTotal)
+		if self.gapsWhere is None: self.gapsWhere = makeDataContainer(leavesTotalAsInt * leavesTotalAsInt + 1, self.__dataclass_fields__['gapsWhere'].metadata['dtype'])
 
-		if self.countDimensionsGapped is None:
-			self.countDimensionsGapped = makeDataContainer(leavesTotalAsInt + 1, numpyLeavesTotal)
-		if self.gapRangeStart is None:
-			self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, numpyElephino)
-		if self.gapsWhere is None:
-			self.gapsWhere = makeDataContainer(leavesTotalAsInt * leavesTotalAsInt + 1, numpyLeavesTotal)
-		if self.leafAbove is None:
-			self.leafAbove = makeDataContainer(leavesTotalAsInt + 1, numpyLeavesTotal)
-		if self.leafBelow is None:
-			self.leafBelow = makeDataContainer(leavesTotalAsInt + 1, numpyLeavesTotal)
+		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'])
 
 	def getFoldsTotal(self) -> None:
 		self.foldsTotal = DatatypeFoldsTotal(self.foldGroups[0:-1].sum() * self.leavesTotal)
 
-# =============================================================================
-
-# 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 = The.pathPackage / "jobs"
-	return pathJobDEFAULT
-
 # =============================================================================
 # The coping way.
 
 class raiseIfNoneGitHubIssueNumber3(Exception): pass
-
-# =============================================================================
-# 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}"
-
-theLogicalPathModuleDispatcher: str = The.logicalPathModuleSourceAlgorithm
-
-theModuleDispatcherSynthetic: str = theFormatStrModuleForCallableSynthetic.format(packageFlow=packageFlowSynthetic, callableTarget=The.dispatcherCallable)
-theLogicalPathModuleDispatcherSynthetic: str = '.'.join([The.packageName, The.moduleOfSyntheticModules, theModuleDispatcherSynthetic])
-
-if Z0Z_packageFlow == packageFlowSynthetic: # pyright: ignore [reportUnnecessaryComparison]
-	# NOTE this as a default value _might_ have value
-	theLogicalPathModuleDispatcher = theLogicalPathModuleDispatcherSynthetic
-
-# 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, The.dispatcherCallable)
-	return dispatcherCallable
-
-"""Technical concepts I am likely using and likely want to use more effectively:
-- Configuration Registry
-- Write-Once, Read-Many (WORM) / Immutable Initialization
-- Lazy Initialization
-- Separate configuration from business logic
-
-----
-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
-"""

{mapfolding-0.8.3.dist-info → mapfolding-0.8.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.8.3
+Version: 0.8.4
 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
@@ -45,6 +45,7 @@ Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pytest-env; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
 Requires-Dist: pyupgrade; extra == "testing"
+Requires-Dist: ruff; extra == "testing"
 Dynamic: license-file
 
 # mapFolding: Algorithms for enumerating distinct map/stamp folding patterns 🗺️

mapfolding-0.8.4.dist-info/RECORD

@@ -0,0 +1,49 @@
+mapFolding/__init__.py,sha256=z3joPk4hgIbSEsIWGgkOukl-nrgI5u4wg0mRJ7aSRHM,1982
+mapFolding/basecamp.py,sha256=CGJOUE0eQsS4EzHjptzJbxg-Oy4t6TsE7P3vgTRuAww,4763
+mapFolding/beDRY.py,sha256=UhH52BryHQNRjphf_PirtMkV45rhdemdC9PmnpACq7I,9397
+mapFolding/filesystem.py,sha256=JyeFLlkeMqhsYGp80ViwDjrrDgFaTTdGTewLtla-m00,7132
+mapFolding/noHomeYet.py,sha256=UKZeWlyn0SKlF9dhYoud7E6gWXpiSEekZOOoJp88WeI,1362
+mapFolding/oeis.py,sha256=F1tGo2kT9xR3eRaXyxH0bnAWscbn38VS2fIY8-VlLZs,12616
+mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/theDao.py,sha256=MVopt1LzhdIQYA97SEoq9bdzct6hbK0lEyPxBAAlVTc,9934
+mapFolding/theSSOT.py,sha256=JCejbNNVP6s9dR2vkdttKXleyZrQroYRWUjGQrXyFaI,11845
+mapFolding/reference/__init__.py,sha256=UIEU8BJR_YDzjFQcLel3XtHzOCJiOUGlGiWzOzbvhik,2206
+mapFolding/reference/flattened.py,sha256=QK1xG9SllqCoi68e86Hyl9d9ATUAAFNpTQI-3zmcp5I,16072
+mapFolding/reference/hunterNumba.py,sha256=espFiX92EPZ1Ub1YQVoBnNYvh2kFg1HR6Qa4djx8Ixg,7253
+mapFolding/reference/irvineJavaPort.py,sha256=UEfIX4QbPLl5jnyfYIyX5YRR3_rYvPUikK8jLehsFko,4076
+mapFolding/reference/jaxCount.py,sha256=TuDNKOnyhQfuixKmIxO9Algv7dvy7KMGhgsV3h96FGE,14853
+mapFolding/reference/lunnanNumpy.py,sha256=mMgrgbrBpe4nmo72ThEI-MGH0OwEHmfMPczSXHp2qKo,4357
+mapFolding/reference/lunnanWhile.py,sha256=ZL8GAQtPs5nJZSgoDl5USrLSS_zs03y98y1Z9E4jOmQ,3799
+mapFolding/reference/rotatedEntryPoint.py,sha256=5ughpKUT2JQhoAKgoDUdYNjgWQYPGV8v-7dWEAdDmfE,10274
+mapFolding/reference/total_countPlus1vsPlusN.py,sha256=yJZAVLVdoXqHag2_N6_6CT-Q6HXBgRro-eny93-Rlpw,9307
+mapFolding/reference/jobsCompleted/__init__.py,sha256=TU93ZGUW1xEkT6d9mQFn_rp5DvRy0ZslEB2Q6MF5ZDc,2596
+mapFolding/reference/jobsCompleted/[2x19]/p2x19.py,sha256=_tvYtfzMWVo2VtUbIAieoscb4N8FFflgTdW4-ljBUuA,19626
+mapFolding/reference/jobsCompleted/p2x19/p2x19.py,sha256=eZEw4Me4ocTt6VXoK2-Sbd5SowZtxRIbN9dZmc7OCVg,6395
+mapFolding/someAssemblyRequired/__init__.py,sha256=v8aBRcRa4d_34SUNu_mZC5K_NC7-buy849k2nnk9lTE,2704
+mapFolding/someAssemblyRequired/_theTypes.py,sha256=nHFgpts-hVy2lNbyvIyP5JeG-ikaIlbRaMUPnEDwzhc,1924
+mapFolding/someAssemblyRequired/_tool_Make.py,sha256=nIAjiq-Q2sBvO_bVEGFh3Z79vXmcqcfJCtuhR4Vyzqw,7081
+mapFolding/someAssemblyRequired/_tool_Then.py,sha256=8ZCI8A6-EtUo02m71h60iJwnWfdwxWiQT0_OWJDFBho,2566
+mapFolding/someAssemblyRequired/_toolboxAntecedents.py,sha256=USqFn2HKiu2aUYUrUI-UVRq2tAvVw2hLtH2uLJ61ZbY,19110
+mapFolding/someAssemblyRequired/_toolboxContainers.py,sha256=jjGyKhblHqDiCzjHRfyqnI2UHNzJTe3aBwNofukcf88,15998
+mapFolding/someAssemblyRequired/_toolboxPython.py,sha256=OSFMNBiyBofzckF6J8OYibm9Zh3GHXB8bJrMggVT8fw,3801
+mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=CDbesDJSQE-P8uznXIAttRw9f413UpUt-RowK38hqbY,2735
+mapFolding/someAssemblyRequired/ingredientsNumba.py,sha256=Qb2WVDv5XszwcQCs3zFrodS7G0GKstSqVrKDXBzdMaw,8128
+mapFolding/someAssemblyRequired/synthesizeNumbaFlow.py,sha256=A9H6gbTNtK0bihxJ98Xv5ePzGeOyYP6e0Fxmj2NTh-M,11186
+mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=_TPANqYkWS4O2IhU4EOatRv-OetfFCfk5b6rrxB5i48,13210
+mapFolding/someAssemblyRequired/transformDataStructures.py,sha256=I4OtFUF7ZNpEzsAbIbcqTifnY1vIwN0v1f-XFQQp3Wk,13558
+mapFolding/someAssemblyRequired/transformationTools.py,sha256=fXr3XKHuFntKLTxoau9ZnbZJRPOG3aS2BhjJvkgRXRs,7932
+mapFolding/syntheticModules/__init__.py,sha256=evVFqhCGa-WZKDiLcnQWjs-Bj34eRnfSLqz_d7dFYZY,83
+mapFolding/syntheticModules/numbaCount_doTheNeedful.py,sha256=3thXThbv2Xo0t_cRGzMbHPFXTBmLClmKejR_Ibu_jOo,15697
+mapfolding-0.8.4.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/conftest.py,sha256=-5rAnacJAuDcG84jeoQAA35GvUTW6YTcT6E_xU7EXQ0,11587
+tests/test_computations.py,sha256=R5gea8liIE_rBYvgRDIby6GljBazuGgqCeYcqKRjORg,3449
+tests/test_filesystem.py,sha256=RplMT0GULGQxomQSbk5wLlvNsj7ehDlZmzayatJopp4,3150
+tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
+tests/test_other.py,sha256=AzsCXiX8x5WJ7i0SocWQY6lT30IJg1lKoybx03X2eqU,4281
+tests/test_tasks.py,sha256=hkZygihT8bCEO2zc-2VcxReQrZJBwgLNbYx0YP4lTDg,2853
+mapfolding-0.8.4.dist-info/METADATA,sha256=NMXRV8HTCO8Nab_q1Bo3W6i0eAirJ9K453LRGOv86i8,9326
+mapfolding-0.8.4.dist-info/WHEEL,sha256=CmyFI0kx5cdEMTLiONQRbGQwjIoR1aIYB7eCAQ4KPJ0,91
+mapfolding-0.8.4.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapfolding-0.8.4.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapfolding-0.8.4.dist-info/RECORD,,

{mapfolding-0.8.3.dist-info → mapfolding-0.8.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (77.0.3)
+Generator: setuptools (78.1.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tests/conftest.py

@@ -1,16 +1,16 @@
-from importlib import import_module as importlib_import_module
 from collections.abc import Callable, Generator, Sequence
-from types import ModuleType
-
-import numpy
-from mapFolding.theSSOT import ComputationState, The, getPackageDispatcher
 from mapFolding.beDRY import getLeavesTotal, validateListDimensions, makeDataContainer
 from mapFolding.oeis import oeisIDsImplemented, settingsOEIS
-from mapFolding.someAssemblyRequired import RecipeSynthesizeFlow
+from mapFolding.someAssemblyRequired import importLogicalPath2Callable
 from mapFolding.someAssemblyRequired.synthesizeNumbaFlow import makeNumbaFlow
+from mapFolding.someAssemblyRequired._toolboxContainers import RecipeSynthesizeFlow
+from mapFolding.theSSOT import ComputationState, The, getPackageDispatcher
 from pathlib import Path, PurePosixPath
+from types import ModuleType
 from typing import Any, ContextManager
+import importlib
 import importlib.util
+import numpy
 import pytest
 import random
 import shutil
@@ -18,8 +18,9 @@ import unittest.mock
 import uuid
 
 # SSOT for test data paths and filenames
-pathDataSamples = Path("tests/dataSamples")
+pathDataSamples = Path("tests/dataSamples").absolute()
 pathTmpRoot: Path = pathDataSamples / "tmp"
+pathTmpRoot.mkdir(parents=True, exist_ok=True)
 
 # The registrar maintains the register of temp files
 registerOfTemporaryFilesystemObjects: set[Path] = set()
@@ -100,7 +101,22 @@ def setupWarningsAsErrors() -> Generator[None, Any, None]:
 	warnings.resetwarnings()
 
 @pytest.fixture
-def listDimensionsTestCountFolds(oeisID: str):
+def oneTestCuzTestsOverwritingTests(oeisID_1random: str) -> tuple[int, ...]:
+	"""For each `oeisID_1random` from the `pytest.fixture`, returns `listDimensions` from `valuesTestValidation`
+	if `validateListDimensions` approves. Each `listDimensions` is suitable for testing counts."""
+	while True:
+		n = random.choice(settingsOEIS[oeisID_1random]['valuesTestValidation'])
+		if n < 2:
+			continue
+		listDimensionsCandidate = list(settingsOEIS[oeisID_1random]['getMapShape'](n))
+
+		try:
+			return validateListDimensions(listDimensionsCandidate)
+		except (ValueError, NotImplementedError):
+			pass
+
+@pytest.fixture
+def listDimensionsTestCountFolds(oeisID: str) -> tuple[int, ...]:
 	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestValidation`
 	if `validateListDimensions` approves. Each `listDimensions` is suitable for testing counts."""
 	while True:
@@ -115,7 +131,7 @@ def listDimensionsTestCountFolds(oeisID: str):
 			pass
 
 @pytest.fixture
-def mapShapeTestFunctionality(oeisID_1random: str):
+def mapShapeTestFunctionality(oeisID_1random: str) -> tuple[int, ...]:
 	"""To test functionality, get one `listDimensions` from `valuesTestValidation` if
 	`validateListDimensions` approves. The algorithm can count the folds of the returned
 	`listDimensions` in a short enough time suitable for testing."""
@@ -159,17 +175,6 @@ def mockFoldingFunction() -> Callable[..., Callable[..., None]]:
 		return mock_countFolds
 	return make_mock
 
-@pytest.fixture
-def mockDispatcher() -> Callable[[Any], ContextManager[Any]]:
-	"""Context manager for mocking dispatcher callable."""
-	def wrapper(mockFunction: Any) -> ContextManager[Any]:
-		dispatcherCallable = getPackageDispatcher()
-		return unittest.mock.patch(
-			f"{dispatcherCallable.__module__}.{dispatcherCallable.__name__}",
-			side_effect=mockFunction
-		)
-	return wrapper
-
 @pytest.fixture(params=oeisIDsImplemented)
 def oeisID(request: pytest.FixtureRequest) -> Any:
 	return request.param
@@ -198,42 +203,42 @@ def useThisDispatcher() -> Generator[Callable[..., None], Any, None]:
 	basecamp.getPackageDispatcher = dispatcherOriginal
 
 def getAlgorithmDispatcher() -> Callable[[ComputationState], ComputationState]:
-	moduleImported: ModuleType = importlib_import_module(The.logicalPathModuleSourceAlgorithm)
-	dispatcherCallable = getattr(moduleImported, The.dispatcherCallable)
+	moduleImported: ModuleType = importlib.import_module(The.logicalPathModuleSourceAlgorithm)
+	dispatcherCallable = getattr(moduleImported, The.sourceCallableDispatcher)
 	return dispatcherCallable
 
 @pytest.fixture
 def useAlgorithmSourceDispatcher(useThisDispatcher: Callable[..., Any]) -> Generator[None, None, None]:
 	"""Temporarily patches getDispatcherCallable to return the algorithm dispatcher."""
-	useThisDispatcher(getAlgorithmDispatcher())
+	useThisDispatcher(importLogicalPath2Callable(The.logicalPathModuleSourceAlgorithm, The.sourceCallableDispatcher))
 	yield
 
 @pytest.fixture
 def syntheticDispatcherFixture(useThisDispatcher: Callable[..., Any], pathTmpTesting: Path) -> Callable[..., Any]:
     """Generate synthetic Numba-optimized dispatcher module and patch the dispatcher"""
     # Configure synthesis flow to use test directory
-    recipeFlow = RecipeSynthesizeFlow(
+    TESTINGrecipeFlow = RecipeSynthesizeFlow(
         pathPackage=PurePosixPath(pathTmpTesting.absolute()),
-        Z0Z_flowLogicalPathRoot=None,
+        logicalPathFlowRoot=None,
         moduleDispatcher="test_dispatcher",
 # Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
         # dispatcherCallable="dispatcherSynthetic",
     )
 
     # Generate optimized module in test directory
-    makeNumbaFlow(recipeFlow)
+    makeNumbaFlow(TESTINGrecipeFlow)
 
     # Import synthesized dispatcher
     importlibSpecificationDispatcher = importlib.util.spec_from_file_location(
-        recipeFlow.moduleDispatcher,
-        Path(recipeFlow.pathFilenameDispatcher),
+        TESTINGrecipeFlow.moduleDispatcher,
+        Path(TESTINGrecipeFlow.pathFilenameDispatcher),
     )
     if importlibSpecificationDispatcher is None or importlibSpecificationDispatcher.loader is None:
         raise ImportError("Failed to load synthetic dispatcher module")
 
     moduleSpecificationDispatcher = importlib.util.module_from_spec(importlibSpecificationDispatcher)
     importlibSpecificationDispatcher.loader.exec_module(moduleSpecificationDispatcher)
-    callableDispatcherSynthetic = getattr(moduleSpecificationDispatcher, recipeFlow.dispatcherCallable)
+    callableDispatcherSynthetic = getattr(moduleSpecificationDispatcher, TESTINGrecipeFlow.callableDispatcher)
 
     # Patch dispatcher and return callable
     useThisDispatcher(callableDispatcherSynthetic)