mapFolding 0.11.1__py3-none-any.whl → 0.11.3__py3-none-any.whl

mapFolding/syntheticModules/countParallel.py

@@ -0,0 +1,98 @@
+from concurrent.futures import Future as ConcurrentFuture, ProcessPoolExecutor
+from copy import deepcopy
+from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3D, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, ParallelMapFoldingState
+from multiprocessing import set_start_method as multiprocessing_set_start_method
+from numba import jit
+if __name__ == '__main__':
+    multiprocessing_set_start_method('spawn')
+
+@jit(cache=True, error_model='numpy', fastmath=True, forceinline=True)
+def count(groupsOfFolds: DatatypeFoldsTotal, gap1ndex: DatatypeElephino, gap1ndexCeiling: DatatypeElephino, indexDimension: DatatypeLeavesTotal, indexLeaf: DatatypeLeavesTotal, indexMiniGap: DatatypeElephino, leaf1ndex: DatatypeLeavesTotal, leafConnectee: DatatypeLeavesTotal, dimensionsUnconstrained: DatatypeLeavesTotal, countDimensionsGapped: Array1DLeavesTotal, gapRangeStart: Array1DElephino, gapsWhere: Array1DLeavesTotal, leafAbove: Array1DLeavesTotal, leafBelow: Array1DLeavesTotal, connectionGraph: Array3D, dimensionsTotal: DatatypeLeavesTotal, leavesTotal: DatatypeLeavesTotal, taskDivisions: DatatypeLeavesTotal, taskIndex: DatatypeLeavesTotal) -> tuple[DatatypeFoldsTotal, DatatypeElephino, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeElephino, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, Array1DLeavesTotal, Array1DElephino, Array1DLeavesTotal, Array1DLeavesTotal, Array1DLeavesTotal, Array3D, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal, DatatypeLeavesTotal]:
+    while leaf1ndex > 0:
+        if leaf1ndex <= 1 or leafBelow[0] == 1:
+            if leaf1ndex > leavesTotal:
+                groupsOfFolds += 1
+            else:
+                dimensionsUnconstrained = dimensionsTotal
+                gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
+                indexDimension = 0
+                while indexDimension < dimensionsTotal:
+                    leafConnectee = connectionGraph[indexDimension, leaf1ndex, leaf1ndex]
+                    if leafConnectee == leaf1ndex:
+                        dimensionsUnconstrained -= 1
+                    else:
+                        while leafConnectee != leaf1ndex:
+                            if leaf1ndex != taskDivisions or leafConnectee % taskDivisions == taskIndex:
+                                gapsWhere[gap1ndexCeiling] = leafConnectee
+                                if countDimensionsGapped[leafConnectee] == 0:
+                                    gap1ndexCeiling += 1
+                                countDimensionsGapped[leafConnectee] += 1
+                            leafConnectee = connectionGraph[indexDimension, leaf1ndex, leafBelow[leafConnectee]]
+                    indexDimension += 1
+                if not dimensionsUnconstrained:
+                    indexLeaf = 0
+                    while indexLeaf < leaf1ndex:
+                        gapsWhere[gap1ndexCeiling] = indexLeaf
+                        gap1ndexCeiling += 1
+                        indexLeaf += 1
+                indexMiniGap = gap1ndex
+                while indexMiniGap < gap1ndexCeiling:
+                    gapsWhere[gap1ndex] = gapsWhere[indexMiniGap]
+                    if countDimensionsGapped[gapsWhere[indexMiniGap]] == dimensionsUnconstrained:
+                        gap1ndex += 1
+                    countDimensionsGapped[gapsWhere[indexMiniGap]] = 0
+                    indexMiniGap += 1
+        while leaf1ndex > 0 and gap1ndex == gapRangeStart[leaf1ndex - 1]:
+            leaf1ndex -= 1
+            leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]
+            leafAbove[leafBelow[leaf1ndex]] = leafAbove[leaf1ndex]
+        if leaf1ndex > 0:
+            gap1ndex -= 1
+            leafAbove[leaf1ndex] = gapsWhere[gap1ndex]
+            leafBelow[leaf1ndex] = leafBelow[leafAbove[leaf1ndex]]
+            leafBelow[leafAbove[leaf1ndex]] = leaf1ndex
+            leafAbove[leafBelow[leaf1ndex]] = leaf1ndex
+            gapRangeStart[leaf1ndex] = gap1ndex
+            leaf1ndex += 1
+    return (groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal, taskDivisions, taskIndex)
+
+def unRepackParallelMapFoldingState(state: ParallelMapFoldingState) -> ParallelMapFoldingState:
+    mapShape: tuple[DatatypeLeavesTotal, ...] = state.mapShape
+    groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
+    gap1ndex: DatatypeElephino = state.gap1ndex
+    gap1ndexCeiling: DatatypeElephino = state.gap1ndexCeiling
+    indexDimension: DatatypeLeavesTotal = state.indexDimension
+    indexLeaf: DatatypeLeavesTotal = state.indexLeaf
+    indexMiniGap: DatatypeElephino = state.indexMiniGap
+    leaf1ndex: DatatypeLeavesTotal = state.leaf1ndex
+    leafConnectee: DatatypeLeavesTotal = state.leafConnectee
+    dimensionsUnconstrained: DatatypeLeavesTotal = state.dimensionsUnconstrained
+    countDimensionsGapped: Array1DLeavesTotal = state.countDimensionsGapped
+    gapRangeStart: Array1DElephino = state.gapRangeStart
+    gapsWhere: Array1DLeavesTotal = state.gapsWhere
+    leafAbove: Array1DLeavesTotal = state.leafAbove
+    leafBelow: Array1DLeavesTotal = state.leafBelow
+    connectionGraph: Array3D = state.connectionGraph
+    dimensionsTotal: DatatypeLeavesTotal = state.dimensionsTotal
+    leavesTotal: DatatypeLeavesTotal = state.leavesTotal
+    taskDivisions: DatatypeLeavesTotal = state.taskDivisions
+    taskIndex: DatatypeLeavesTotal = state.taskIndex
+    groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal, taskDivisions, taskIndex = count(groupsOfFolds, gap1ndex, gap1ndexCeiling, indexDimension, indexLeaf, indexMiniGap, leaf1ndex, leafConnectee, dimensionsUnconstrained, countDimensionsGapped, gapRangeStart, gapsWhere, leafAbove, leafBelow, connectionGraph, dimensionsTotal, leavesTotal, taskDivisions, taskIndex)
+    state = ParallelMapFoldingState(mapShape=mapShape, groupsOfFolds=groupsOfFolds, gap1ndex=gap1ndex, gap1ndexCeiling=gap1ndexCeiling, indexDimension=indexDimension, indexLeaf=indexLeaf, indexMiniGap=indexMiniGap, leaf1ndex=leaf1ndex, leafConnectee=leafConnectee, dimensionsUnconstrained=dimensionsUnconstrained, countDimensionsGapped=countDimensionsGapped, gapRangeStart=gapRangeStart, gapsWhere=gapsWhere, leafAbove=leafAbove, leafBelow=leafBelow, taskDivisions=taskDivisions, taskIndex=taskIndex)
+    return state
+
+def doTheNeedful(state: ParallelMapFoldingState, concurrencyLimit: int) -> tuple[int, list[ParallelMapFoldingState]]:
+    stateParallel = deepcopy(state)
+    listStatesParallel: list[ParallelMapFoldingState] = [stateParallel] * stateParallel.taskDivisions
+    groupsOfFoldsTotal: int = 0
+    dictionaryConcurrency: dict[int, ConcurrentFuture[ParallelMapFoldingState]] = {}
+    with ProcessPoolExecutor(concurrencyLimit) as concurrencyManager:
+        for indexSherpa in range(stateParallel.taskDivisions):
+            state = deepcopy(stateParallel)
+            state.taskIndex = indexSherpa
+            dictionaryConcurrency[indexSherpa] = concurrencyManager.submit(unRepackParallelMapFoldingState, state)
+        for indexSherpa in range(stateParallel.taskDivisions):
+            listStatesParallel[indexSherpa] = dictionaryConcurrency[indexSherpa].result()
+            groupsOfFoldsTotal += listStatesParallel[indexSherpa].groupsOfFolds
+    foldsTotal: int = groupsOfFoldsTotal * stateParallel.leavesTotal
+    return (foldsTotal, listStatesParallel)

mapFolding/syntheticModules/dataPacking.py

@@ -1,7 +1,7 @@
 from mapFolding.dataBaskets import Array1DElephino, Array1DLeavesTotal, Array3D, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, MapFoldingState
 from mapFolding.syntheticModules.theorem2Numba import count
 
-def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+def sequential(state: MapFoldingState) -> MapFoldingState:
     mapShape: tuple[DatatypeLeavesTotal, ...] = state.mapShape
     groupsOfFolds: DatatypeFoldsTotal = state.groupsOfFolds
     gap1ndex: DatatypeElephino = state.gap1ndex

mapFolding/theSSOT.py

@@ -1,268 +1,34 @@
-"""
-Single Source of Truth module for configuration, types, and computational state management.
-
-This module defines the core data structures, type definitions, and configuration settings used throughout the
-mapFolding package. It implements the Single Source of Truth (SSOT) principle to ensure consistency across the package's
-components.
-
-Key features:
-1. The `ComputationState` dataclass, which encapsulates the state of the folding computation.
-2. Unified type definitions for integers and arrays used in the computation.
-3. Configuration settings for synthetic module generation and dispatching.
-4. Path resolution and management for package resources and job output.
-5. Dynamic dispatch functionality for algorithm implementations.
-
-The module differentiates between "the" identifiers (package defaults) and other identifiers 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 pathlib import Path
 from tomli import load as tomli_load
-from types import ModuleType
 import dataclasses
-from mapFolding.datatypes import (
-	Array1DElephino as Array1DElephino,
-	Array1DFoldsTotal as Array1DFoldsTotal,
-	Array1DLeavesTotal as Array1DLeavesTotal,
-	Array3D as Array3D,
-	DatatypeElephino as DatatypeElephino,
-	DatatypeFoldsTotal as DatatypeFoldsTotal,
-	DatatypeLeavesTotal as DatatypeLeavesTotal,
-	NumPyElephino as NumPyElephino,
-	NumPyFoldsTotal as NumPyFoldsTotal,
-	NumPyIntegerType as NumPyIntegerType,
-	NumPyLeavesTotal as NumPyLeavesTotal,
-)
 
-# Evaluate When Packaging https://github.com/hunterhogan/mapFolding/issues/18
+packageNamePACKAGING_HARDCODED = "mapFolding"
+concurrencyPackageHARDCODED = 'multiprocessing'
+
+# Evaluate When Packaging
+# https://github.com/hunterhogan/mapFolding/issues/18
 try:
 	packageNamePACKAGING: str = tomli_load(Path("../pyproject.toml").open('rb'))["project"]["name"]
 except Exception:
-	packageNamePACKAGING = "mapFolding"
+	packageNamePACKAGING = packageNamePACKAGING_HARDCODED
 
-# Evaluate When Installing https://github.com/hunterhogan/mapFolding/issues/18
+# Evaluate When Installing
+# https://github.com/hunterhogan/mapFolding/issues/18
 def getPathPackageINSTALLING() -> Path:
 	pathPackage: Path = Path(inspect_getfile(importlib_import_module(packageNamePACKAGING)))
 	if pathPackage.is_file():
 		pathPackage = pathPackage.parent
 	return pathPackage
 
-# I believe these values should be dynamically determined, so I have conspicuously marked them "HARDCODED"
-# and created downstream logic that assumes the values were dynamically determined.
-# Figure out dynamic flow control to synthesized modules https://github.com/hunterhogan/mapFolding/issues/4
-logicalPathModuleDispatcherHARDCODED: str = 'mapFolding.syntheticModules.numbaCount'
-callableDispatcherHARDCODED: str = 'doTheNeedful'
-concurrencyPackageHARDCODED = 'multiprocessing'
-# from mapFolding.someAssemblyRequired.toolboxNumba.theNumbaFlow
-
-# PackageSettings in theSSOT.py and immutability https://github.com/hunterhogan/mapFolding/issues/11
 @dataclasses.dataclass
 class PackageSettings:
-	"""
-	Centralized configuration settings for the mapFolding package.
-
-	This class implements the Single Source of Truth (SSOT) principle for package configuration, providing a consistent
-	interface for accessing package settings, paths, and dispatch functions. The primary instance of this class, named
-	`The`, is imported and used throughout the package to retrieve configuration values.
-	"""
-
-	logicalPathModuleDispatcher: str | None = None
-	"""Logical import path to the module containing the dispatcher function."""
-
-	callableDispatcher: str | None = None
-	"""Name of the function within the dispatcher module that will be called."""
-
-	concurrencyPackage: str | None = None
-	"""Package to use for concurrent execution (e.g., 'multiprocessing', 'numba')."""
-
-	# "Evaluate When Packaging" and "Evaluate When Installing" https://github.com/hunterhogan/mapFolding/issues/18
-	dataclassIdentifier: str = dataclasses.field(default='ComputationState', metadata={'evaluateWhen': 'packaging'})
-	"""Name of the dataclass used to track computation state."""
-
-	dataclassInstance: str = dataclasses.field(default='state', metadata={'evaluateWhen': 'packaging'})
-	"""Default variable name for instances of the computation state dataclass."""
-
-	dataclassInstanceTaskDistributionSuffix: str = dataclasses.field(default='Parallel', metadata={'evaluateWhen': 'packaging'})
-	"""Suffix added to dataclassInstance for parallel task distribution."""
-
-	dataclassModule: str = dataclasses.field(default='theSSOT', metadata={'evaluateWhen': 'packaging'})
-	"""Module containing the computation state dataclass definition."""
-
-	datatypePackage: str = dataclasses.field(default='numpy', metadata={'evaluateWhen': 'packaging'})
-	"""Package providing the numeric data types used in computation."""
-
 	fileExtension: str = dataclasses.field(default='.py', metadata={'evaluateWhen': 'installing'})
-	"""Default file extension for generated code files."""
-
 	packageName: str = dataclasses.field(default = packageNamePACKAGING, metadata={'evaluateWhen': 'packaging'})
-	"""Name of this package, used for import paths and configuration."""
-
 	pathPackage: Path = dataclasses.field(default_factory=getPathPackageINSTALLING, metadata={'evaluateWhen': 'installing'})
-	"""Absolute path to the installed package directory."""
-
-	sourceAlgorithm: str = dataclasses.field(default='theDao', metadata={'evaluateWhen': 'packaging'})
-	"""Module containing the reference implementation of the algorithm."""
-
-	sourceCallableDispatcher: str = dataclasses.field(default='doTheNeedful', metadata={'evaluateWhen': 'packaging'})
-	"""Name of the function that dispatches computation in the source algorithm."""
-
-	sourceCallableInitialize: str = dataclasses.field(default='countInitialize', metadata={'evaluateWhen': 'packaging'})
-	"""Name of the function that initializes computation in the source algorithm."""
-
-	sourceCallableParallel: str = dataclasses.field(default='countParallel', metadata={'evaluateWhen': 'packaging'})
-	"""Name of the function that performs parallel computation in the source algorithm."""
-
-	sourceCallableSequential: str = dataclasses.field(default='countSequential', metadata={'evaluateWhen': 'packaging'})
-	"""Name of the function that performs sequential computation in the source algorithm."""
-
-	sourceConcurrencyManagerIdentifier: str = dataclasses.field(default='submit', metadata={'evaluateWhen': 'packaging'})
-	"""Method name used to submit tasks to the concurrency manager."""
-
-	sourceConcurrencyManagerNamespace: str = dataclasses.field(default='concurrencyManager', metadata={'evaluateWhen': 'packaging'})
-	"""Variable name used for the concurrency manager instance."""
-
-	sourceConcurrencyPackage: str = dataclasses.field(default='multiprocessing', metadata={'evaluateWhen': 'packaging'})
-	"""Default package used for concurrency in the source algorithm."""
-
-	dataclassInstanceTaskDistribution: str = dataclasses.field(default=None, metadata={'evaluateWhen': 'packaging'}) # pyright: ignore[reportAssignmentType]
-	"""Variable name for the parallel distribution instance of the computation state."""
-
-	logicalPathModuleDataclass: str = dataclasses.field(default=None, metadata={'evaluateWhen': 'packaging'}) # pyright: ignore[reportAssignmentType]
-	"""Fully qualified import path to the module containing the computation state dataclass."""
-
-	logicalPathModuleSourceAlgorithm: str = dataclasses.field(default=None, metadata={'evaluateWhen': 'packaging'}) # pyright: ignore[reportAssignmentType]
-	"""Fully qualified import path to the module containing the source algorithm."""
-
-	@property
-	def dispatcher(self) -> Callable[['ComputationState'], 'ComputationState']:
-		""" _The_ callable that connects `countFolds` to the logic that does the work."""
-		logicalPath: str = self.logicalPathModuleDispatcher or self.logicalPathModuleSourceAlgorithm
-		identifier: str = self.callableDispatcher or self.sourceCallableDispatcher
-		moduleImported: ModuleType = importlib_import_module(logicalPath)
-		return getattr(moduleImported, identifier)
-
-	def __post_init__(self) -> None:
-		if self.dataclassInstanceTaskDistribution is None: # pyright: ignore[reportUnnecessaryComparison]
-			self.dataclassInstanceTaskDistribution = self.dataclassInstance + self.dataclassInstanceTaskDistributionSuffix
-
-		if self.logicalPathModuleDataclass is None: # pyright: ignore[reportUnnecessaryComparison]
-			self.logicalPathModuleDataclass = '.'.join([self.packageName, self.dataclassModule])
-		if self.logicalPathModuleSourceAlgorithm is None: # pyright: ignore[reportUnnecessaryComparison]
-			self.logicalPathModuleSourceAlgorithm = '.'.join([self.packageName, self.sourceAlgorithm])
-
-The = PackageSettings(logicalPathModuleDispatcher=logicalPathModuleDispatcherHARDCODED, callableDispatcher=callableDispatcherHARDCODED, concurrencyPackage=concurrencyPackageHARDCODED)
-
-@dataclasses.dataclass
-class ComputationState:
-	"""
-	Represents the complete state of a map folding computation.
-
-	This dataclass encapsulates all the information required to compute the number of possible ways to fold a map,
-	including the map dimensions, leaf connections, computation progress, and fold counting. It serves as the central
-	data structure that flows through the entire computational algorithm.
-
-	Fields are categorized into:
-	1. Input parameters (`mapShape`, `leavesTotal`, etc.).
-	2. Core computational structures (`connectionGraph`, etc.).
-	3. Tracking variables for the folding algorithm state.
-	4. Result accumulation fields (`foldsTotal`, `groupsOfFolds`).
-	"""
-	# NOTE Python is anti-DRY, again, `DatatypeLeavesTotal` metadata needs to match the type
-	mapShape: tuple[DatatypeLeavesTotal, ...] = dataclasses.field(init=True, metadata={'elementConstructor': 'DatatypeLeavesTotal'})
-	"""Dimensions of the map to be folded, as a tuple of integers."""
-
-	leavesTotal: DatatypeLeavesTotal
-	"""Total number of leaves (unit squares) in the map, equal to the product of all dimensions."""
-
-	taskDivisions: DatatypeLeavesTotal
-	"""Number of parallel tasks to divide the computation into. Zero means sequential computation."""
-
-	concurrencyLimit: DatatypeElephino
-	"""Maximum number of concurrent processes to use during computation."""
-
-	connectionGraph: Array3D = dataclasses.field(init=False, metadata={'dtype': Array3D.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
-	"""3D array encoding the connections between leaves in all dimensions."""
-
-	dimensionsTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
-	"""Total number of dimensions in the map shape."""
-
-	# I am using `dataclasses.field` metadata and `typeAlias.__args__[1].__args__[0]` to make the code more DRY. https://github.com/hunterhogan/mapFolding/issues/9
-	countDimensionsGapped: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""Tracks how many dimensions are gapped for each leaf."""
-
-	dimensionsUnconstrained: DatatypeLeavesTotal = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""Number of dimensions that are not constrained in the current folding state."""
-
-	gapRangeStart: Array1DElephino = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DElephino.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""Starting index for the gap range for each leaf."""
-
-	gapsWhere: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""Tracks where gaps occur in the folding pattern."""
-
-	leafAbove: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""For each leaf, stores the index of the leaf above it in the folding pattern."""
-
-	leafBelow: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""For each leaf, stores the index of the leaf below it in the folding pattern."""
-
-	foldGroups: Array1DFoldsTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DFoldsTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""Accumulator for fold groups across parallel tasks."""
-
-	foldsTotal: DatatypeFoldsTotal = DatatypeFoldsTotal(0)
-	"""The final computed total number of distinct folding patterns."""
-
-	gap1ndex: DatatypeElephino = DatatypeElephino(0)
-	"""Current index into gaps array during algorithm execution."""
-
-	gap1ndexCeiling: DatatypeElephino = DatatypeElephino(0)
-	"""Upper limit for gap index during the current algorithm phase."""
-
-	groupsOfFolds: DatatypeFoldsTotal = dataclasses.field(default=DatatypeFoldsTotal(0), metadata={'theCountingIdentifier': True})
-	"""Accumulator for the number of fold groups found during computation."""
-
-	indexDimension: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
-	"""Current dimension being processed during algorithm execution."""
-
-	indexLeaf: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
-	"""Current leaf index during iteration."""
-
-	indexMiniGap: DatatypeElephino = DatatypeElephino(0)
-	"""Index used when filtering common gaps."""
-
-	leaf1ndex: DatatypeLeavesTotal = DatatypeLeavesTotal(1)
-	"""Active leaf being processed in the folding algorithm. Starts at 1, not 0."""
-
-	leafConnectee: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
-	"""Leaf that is being connected to the active leaf."""
-
-	taskIndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
-	"""Index of the current parallel task when using task divisions."""
-
-	def __post_init__(self) -> None:
-		from mapFolding.beDRY import getConnectionGraph, makeDataContainer
-		self.dimensionsTotal = DatatypeLeavesTotal(len(self.mapShape))
-		leavesTotalAsInt = int(self.leavesTotal)
-		self.connectionGraph = getConnectionGraph(self.mapShape, leavesTotalAsInt, self.__dataclass_fields__['connectionGraph'].metadata['dtype'])
-
-		if self.dimensionsUnconstrained is None: self.dimensionsUnconstrained = DatatypeLeavesTotal(int(self.dimensionsTotal)) # pyright: ignore[reportUnnecessaryComparison]
-
-		if self.foldGroups is None: # pyright: ignore[reportUnnecessaryComparison]
-			self.foldGroups = makeDataContainer(max(2, int(self.taskDivisions) + 1), self.__dataclass_fields__['foldGroups'].metadata['dtype'])
-			self.foldGroups[-1] = self.leavesTotal
-
-		# Dataclasses, Default factories, and arguments in `ComputationState` https://github.com/hunterhogan/mapFolding/issues/12
-		if self.gapsWhere is None: self.gapsWhere = makeDataContainer(leavesTotalAsInt * leavesTotalAsInt + 1, self.__dataclass_fields__['gapsWhere'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
-
-		if self.countDimensionsGapped is None: self.countDimensionsGapped = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['countDimensionsGapped'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
-		if self.gapRangeStart is None: self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['gapRangeStart'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
-		if self.leafAbove is None: self.leafAbove = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafAbove'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
-		if self.leafBelow is None: self.leafBelow = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafBelow'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
-
-	# Automatic, or not, calculation in dataclass `ComputationState` https://github.com/hunterhogan/mapFolding/issues/14
-	def getFoldsTotal(self) -> None:
-		self.foldsTotal = DatatypeFoldsTotal(self.foldGroups[0:-1].sum() * self.leavesTotal)
+	concurrencyPackage: str | None = None
+	"""Package to use for concurrent execution (e.g., 'multiprocessing', 'numba')."""
 
-class raiseIfNoneGitHubIssueNumber3(Exception): pass
+concurrencyPackage = concurrencyPackageHARDCODED
+packageSettings = PackageSettings(concurrencyPackage=concurrencyPackage)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.11.1
+Version: 0.11.3
 Summary: Map folding algorithm with code transformation framework for optimizing numerical computations
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -33,8 +33,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: astToolkit
 Requires-Dist: autoflake
-Requires-Dist: cytoolz
-Requires-Dist: more_itertools
 Requires-Dist: numba_progress
 Requires-Dist: numba
 Requires-Dist: numpy
@@ -42,7 +40,6 @@ Requires-Dist: platformdirs
 Requires-Dist: python_minifier
 Requires-Dist: sympy
 Requires-Dist: tomli
-Requires-Dist: typeshed_client
 Requires-Dist: Z0Z_tools
 Provides-Extra: testing
 Requires-Dist: mypy; extra == "testing"
@@ -67,12 +64,6 @@ Dynamic: license-file
 - You're interested in solving mathematical puzzles through code
 - You're learning about Numba and advanced Python optimization
 
-**This package is NOT for you if:**
-
-- You're looking for a general-purpose folding simulation tool
-- You need commercial-ready mapping software
-- You want simple visualization of folding patterns
-
 ## What Does This Package Actually Do?
 
 `mapFolding` solves a specific mathematical problem: counting the number of distinct ways to fold a rectangular map. While this may sound niche, it's a fascinating computational challenge that demonstrates:
@@ -87,7 +78,7 @@ The package has achieved new computational records, including first-ever calcula
 ```python
 # Compute the number of ways to fold a 5×5 grid:
 from mapFolding import oeisIDfor_n
-foldsTotal = oeisIDfor_n('A001418', 5)  # Returns 186,086,600
+foldsTotal = oeisIDfor_n('A001418', 5)
 ```
 
 ## Key Benefits for Computational Enthusiasts
@@ -178,4 +169,18 @@ If you've read this far and are intrigued by computational puzzles, algorithm op
 
 Whether you use it to solve map folding problems or to study its optimization techniques, `mapFolding` offers a unique window into advanced Python programming approaches.
 
+## My recovery
+
+[![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
+[![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)
+
+## How to code
+
+Coding One Step at a Time:
+
+0. WRITE CODE.
+1. Don't write stupid code that's hard to revise.
+2. Write good code.
+3. When revising, write better code.
+
 [![CC-BY-NC-4.0](https://github.com/hunterhogan/mapFolding/blob/main/CC-BY-NC-4.0.svg)](https://creativecommons.org/licenses/by-nc/4.0/)

mapfolding-0.11.3.dist-info/RECORD

@@ -0,0 +1,53 @@
+mapFolding/__init__.py,sha256=5aecz_WZCLtBsArV68h30OEQxrylPPm0oVfQMt0N94A,1948
+mapFolding/basecamp.py,sha256=3MMWSN8eW4W_dZe_q7Vs5yqmazNFoml0VpcJNY2feho,8243
+mapFolding/beDRY.py,sha256=kQrgBhJkXEy-J-Zyu4RHILK6gRm72a7cON7a1LewgwI,14004
+mapFolding/daoOfMapFolding.py,sha256=ncTIiBfTsM8SNVx9qefZ0bBcBtviWLSk4iPv3Z9nGiE,5442
+mapFolding/dataBaskets.py,sha256=crfmmYJGeJ7QLCzuYi4rtVOtzCDRoOiTNfPfHbc6Foo,5620
+mapFolding/datatypes.py,sha256=dqOAa2RbiGcsRl9X4qo4tdMamgOoZVnewrMjY4mHXS4,773
+mapFolding/filesystemToolkit.py,sha256=O9VQ0tSXlrGUhU3qN7uWxOTAZfuQb3fcRkTrfRZrGXo,9854
+mapFolding/oeis.py,sha256=ifs9Uu4uqgKCd46aHuCqhyXt2JXLMcPmmWRFuXIBACg,16926
+mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/theSSOT.py,sha256=7CyB3FnDWyNovTuUPRvSIfF7GxQc3aZoIsIwF1-4OyE,1456
+mapFolding/reference/__init__.py,sha256=GKcSgYE49NcTISx-JZbELXyq-eRkMeTL5g4DXInWFw0,2206
+mapFolding/reference/flattened.py,sha256=QK1xG9SllqCoi68e86Hyl9d9ATUAAFNpTQI-3zmcp5I,16072
+mapFolding/reference/hunterNumba.py,sha256=iLfyqwGdAh6c5GbapnKsWhAsNsR3O-fyGGHAdohluLw,7258
+mapFolding/reference/irvineJavaPort.py,sha256=UEfIX4QbPLl5jnyfYIyX5YRR3_rYvPUikK8jLehsFko,4076
+mapFolding/reference/jaxCount.py,sha256=TuDNKOnyhQfuixKmIxO9Algv7dvy7KMGhgsV3h96FGE,14853
+mapFolding/reference/lunnonNumpy.py,sha256=mMgrgbrBpe4nmo72ThEI-MGH0OwEHmfMPczSXHp2qKo,4357
+mapFolding/reference/lunnonWhile.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/RecipeJob.py,sha256=H53d1pIxh6kvEsh9Nmj7bD8agMBbpHziY2XrN808eGc,4432
+mapFolding/someAssemblyRequired/Z0Z_makeAllModules.py,sha256=7REamiISEiZQ_goseQB2BJW4kMb4wRhoJnqhIRdX_zI,30262
+mapFolding/someAssemblyRequired/__init__.py,sha256=Wq8rrFJzZsQV4oYQmDXSlDtAlU4TRgMc5o0EKJedvGE,2705
+mapFolding/someAssemblyRequired/_toolIfThis.py,sha256=nq7brHOA4JOK9P-RWyOFae6QxzX40nV46DNDrNmkLYo,3122
+mapFolding/someAssemblyRequired/_toolkitContainers.py,sha256=C-GkXSYoneWmcJWULPa5bgLidjjcIFbrEtEpnrK1m_Y,9784
+mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=9RPU6vK_eUg64GtVFI_nZnvUryXw8gfHJs9NyDYHIvg,2745
+mapFolding/someAssemblyRequired/infoBooth.py,sha256=IXzpt_YKkWfOOiaQaBh61SiEd-TnLRlHifmq_1mCow4,4249
+mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py,sha256=6bKLNI9po2qS1_JsKr4wnqwY1A5eL5LQN9uLu3jTlkM,14039
+mapFolding/someAssemblyRequired/toolkitNumba.py,sha256=c-rq2rY-Vr0X4asnGy2cmmKTJonv2Jh_mw3oWHT1ctI,6649
+mapFolding/someAssemblyRequired/transformationTools.py,sha256=ysvZaP8XqxXjHtSHlaErNDGHI5OrRRcqVhnzs3F8UUA,8256
+mapFolding/syntheticModules/__init__.py,sha256=evVFqhCGa-WZKDiLcnQWjs-Bj34eRnfSLqz_d7dFYZY,83
+mapFolding/syntheticModules/countParallel.py,sha256=OK_IB9w4yy9MMAiGvkei5ezPm_00v2nYjPrQZ_IlELg,7733
+mapFolding/syntheticModules/daoOfMapFolding.py,sha256=cfWPABtXyCxJ0BwPI7rhfLh_2UYV_XKAL8lJ4GLNXaQ,5896
+mapFolding/syntheticModules/dataPacking.py,sha256=m_eOZ7sMXIQ9jY5EvC3qgitQTY60n6rksy0ACMJOIC8,2292
+mapFolding/syntheticModules/initializeCount.py,sha256=nWSlJMMfIM3DvZxMn6ISQusUJqRYAjKQyLF5hwLEdBQ,3119
+mapFolding/syntheticModules/theorem2.py,sha256=9jrbZNNX4BWYZW1S0JjvRY2k7RU7I1RNUMV7JdCt1ZY,3017
+mapFolding/syntheticModules/theorem2Numba.py,sha256=-cKjNyxgUMFhEyFVs0VJ7hw4LfrV0WSNK5tPYbQ1oNU,3369
+mapFolding/syntheticModules/theorem2Trimmed.py,sha256=DHW3NxBdtABQYBKm2WRvfQ5kzc2_UwGI2h4ePuYEJoM,2685
+mapfolding-0.11.3.dist-info/licenses/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+tests/__init__.py,sha256=5VhHf0JJ2_DSh58zJ0rR5UkpoCon-0IkdljspTCzZ04,1950
+tests/conftest.py,sha256=eumQRoDuWVrhsjDxWXGhW0N7lH0ZZ9XD-5q81bWFqOs,10874
+tests/test_computations.py,sha256=HNpfs9Yz3rdfJInD15Jwd6DYsSR5TCwnR5EW0n7KbeI,5682
+tests/test_filesystem.py,sha256=imlcetleJc4G9pDZTgS1j8UAs7ADbRxXVuNPecJAvqc,2964
+tests/test_oeis.py,sha256=uxvwmgbnylSDdsVJfuAT0LuYLbIVFwSgdLxHm-xUGBM,5043
+tests/test_other.py,sha256=DT7YE82YCHrSjdxhpY4UJnXmZvDm1b4e1QpZV3LyzcM,3747
+tests/test_tasks.py,sha256=pEDukf2SVTOMEsn82JpAWKQzn1ZCTlkhLzQ5hYLg2yY,2780
+mapfolding-0.11.3.dist-info/METADATA,sha256=FyB0PTluboy3BsrccAJJGrEhGpo5nUsbd3JJe6CAsXo,7712
+mapfolding-0.11.3.dist-info/WHEEL,sha256=0CuiUZ_p9E4cD6NyLD6UG80LBXYyiSYZOKDm5lp32xk,91
+mapfolding-0.11.3.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapfolding-0.11.3.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapfolding-0.11.3.dist-info/RECORD,,

{mapfolding-0.11.1.dist-info → mapfolding-0.11.3.dist-info}/WHEEL

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

tests/conftest.py

@@ -56,15 +56,10 @@ See the examples in `test_computations.py` for guidance on adapting these fixtur
 """
 
 from collections.abc import Callable, Generator, Sequence
-from mapFolding import The
-from mapFolding.beDRY import getLeavesTotal, validateListDimensions, makeDataContainer
+from mapFolding import getLeavesTotal, validateListDimensions, makeDataContainer
 from mapFolding.oeis import oeisIDsImplemented, settingsOEIS
-from mapFolding.someAssemblyRequired import importLogicalPath2Callable, RecipeSynthesizeFlow
-from pathlib import Path, PurePosixPath
-from types import ModuleType
+from pathlib import Path
 from typing import Any
-import importlib
-import importlib.util
 import numpy
 import pytest
 import random
@@ -239,78 +234,6 @@ def oeisID_1random() -> str:
 	"""Return one random valid OEIS ID."""
 	return random.choice(oeisIDsImplemented)
 
-@pytest.fixture
-def useThisDispatcher() -> Generator[Callable[..., None], Any, None]:
-	"""A fixture providing a context manager for temporarily replacing the dispatcher.
-
-	Returns
-		A context manager for patching the dispatcher
-	"""
-	import mapFolding.theSSOT as theSSOT
-	from mapFolding.theSSOT import The
-
-	# Store original property method
-	original_dispatcher_property = theSSOT.PackageSettings.dispatcher
-
-	def patchDispatcher(callableTarget: Callable[..., Any]) -> None:
-		"""Patch the dispatcher property to return the target callable."""
-		# Create a new property that returns the target callable
-		def patched_dispatcher(self: theSSOT.PackageSettings) -> Callable[..., Any]:
-			def wrapper(state: Any) -> Any:
-				return callableTarget(state)
-			return wrapper
-
-		# Replace the property with our patched version
-		theSSOT.PackageSettings.dispatcher = property(patched_dispatcher) # type: ignore
-
-	yield patchDispatcher
-
-	# Restore the original property
-	theSSOT.PackageSettings.dispatcher = original_dispatcher_property # type: ignore
-
-def getAlgorithmDispatcher() -> Callable[..., Any]:
-	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(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"""
-	from mapFolding.someAssemblyRequired.toolboxNumba import makeNumbaFlow
-
-	TESTINGrecipeFlow = RecipeSynthesizeFlow(
-		pathPackage=PurePosixPath(pathTmpTesting.absolute()),
-		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(TESTINGrecipeFlow)
-
-	# Import synthesized dispatcher
-	importlibSpecificationDispatcher = importlib.util.spec_from_file_location(
-		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, TESTINGrecipeFlow.callableDispatcher)
-
-	# Patch dispatcher and return callable
-	useThisDispatcher(callableDispatcherSynthetic)
-	return callableDispatcherSynthetic
-
 def uniformTestMessage(expected: Any, actual: Any, functionName: str, *arguments: Any) -> str:
 	"""Format assertion message for any test comparison."""
 	return (f"\nTesting: `{functionName}({', '.join(str(parameter) for parameter in arguments)})`\n"