mapFolding 0.3.12__py3-none-any.whl → 0.4.1__py3-none-any.whl

mapFolding-0.4.1.dist-info/METADATA

@@ -0,0 +1,154 @@
+Metadata-Version: 2.2
+Name: mapFolding
+Version: 0.4.1
+Summary: Count distinct ways to fold a map (or a strip of stamps)
+Author-email: Hunter Hogan <HunterHogan@pm.me>
+License: CC-BY-NC-4.0
+Project-URL: Donate, https://www.patreon.com/integrated
+Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
+Project-URL: Repository, https://github.com/hunterhogan/mapFolding.git
+Keywords: A001415,A001416,A001417,A001418,A195646,combinatorics,folding,map folding,OEIS,optimization,stamp folding
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Other Audience
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numba
+Requires-Dist: numpy
+Requires-Dist: Z0Z_tools
+Provides-Extra: testing
+Requires-Dist: autoflake; extra == "testing"
+Requires-Dist: more_itertools; extra == "testing"
+Requires-Dist: pytest-cov; extra == "testing"
+Requires-Dist: pytest-env; extra == "testing"
+Requires-Dist: pytest-xdist; extra == "testing"
+Requires-Dist: pytest; extra == "testing"
+Requires-Dist: python_minifier; extra == "testing"
+Requires-Dist: updateCitation; extra == "testing"
+
+# mapFolding: Algorithms for enumerating distinct map/stamp folding patterns 🗺️
+
+[![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/)
+[![Static Badge](https://img.shields.io/badge/stinkin'%20badges-don't%20need-b98e5e)](https://youtu.be/g6f_miE91mk&t=4)
+[![Python Tests](https://github.com/hunterhogan/mapFolding/actions/workflows/pythonTests.yml/badge.svg)](https://github.com/hunterhogan/mapFolding/actions/workflows/pythonTests.yml)
+![Static Badge](https://img.shields.io/badge/issues-I%20have%20them-brightgreen)
+[![License: CC-BY-NC-4.0](https://img.shields.io/badge/License-CC_BY--NC_4.0-3b434b)](https://creativecommons.org/licenses/by-nc/4.0/)
+![PyPI - Downloads](https://img.shields.io/pypi/dd/mapFolding)
+![GitHub repo size](https://img.shields.io/github/repo-size/hunterhogan/mapFolding)
+
+---
+
+## Quick start
+
+```sh
+pip install mapFolding
+```
+
+`OEIS_for_n` will run a computation from the command line.
+
+```cmd
+(mapFolding) C:\apps\mapFolding> OEIS_for_n A001418 5
+186086600 distinct folding patterns.
+Time elapsed: 1.605 seconds
+```
+
+Use `mapFolding.oeisIDfor_n()` to compute a(n) for an OEIS ID.
+
+```python
+from mapFolding import oeisIDfor_n
+foldsTotal = oeisIDfor_n( 'A001418', 4 )
+```
+
+---
+
+## Features
+
+### 1. Simple, easy usage based on OEIS IDs
+
+`mapFolding` directly implements some IDs from [_The On-Line Encyclopedia of Integer Sequences_](https://oeis.org/) ([BibTex](https://github.com/hunterhogan/mapFolding/blob/main/citations/oeis.bibtex) citation).
+
+Use `getOEISids` to get the most up-to-date list of available OEIS IDs.
+
+```cmd
+(mapFolding) C:\apps\mapFolding> getOEISids
+
+Available OEIS sequences:
+  A001415: Number of ways of folding a 2 X n strip of stamps.
+  A001416: Number of ways of folding a 3 X n strip of stamps.
+  A001417: Number of ways of folding a 2 X 2 X ... X 2 n-dimensional map.
+  A001418: Number of ways of folding an n X n sheet of stamps.
+  A195646: Number of ways of folding a 3 X 3 X ... X 3 n-dimensional map.
+```
+
+### 2. **Algorithm Zoo** 🦒
+
+- **Lunnon’s 1971 Algorithm**: A painstakingly debugged version of [the original typo-riddled code](https://github.com/hunterhogan/mapFolding/blob/mapFolding/reference/foldings.txt)
+- The /reference directory.
+- **Numba-JIT Accelerated**: Up to 1000× faster than pure Python ([benchmarks](https://github.com/hunterhogan/mapFolding/blob/mapFolding/notes/Speed%20highlights.md))
+
+### 3. **For Researchers** 🔬
+
+- Change multiple minute settings, such as the bit width of the data types.
+- Transform the algorithm using AST
+- Create hyper-optimized modules to compute a specific map.
+
+### 4. **Customizing your algorithm**
+
+- mapFolding\someAssemblyRequired\synthesizeNumbaJob.py (and/or synthesizeNumba____.py, as applicable)
+  - Synthesize a Numba-optimized module for a specific mapShape
+  - Synthesize _from_ a module in mapFolding\syntheticModules or from any source you select
+  - Use the existing transformation options
+  - Or create new ways of transforming the algorithm from its source to a specific job
+- mapFolding\someAssemblyRequired\makeJob.py
+  - Initialize data for a specific mapShape
+- mapFolding\someAssemblyRequired\synthesizeNumbaModules.py (and/or synthesizeNumba____.py, as applicable)
+  - Synthesize one or more Numba-optimized modules for parallel or sequential computation
+  - Overwrite the modules in mapFolding\syntheticModules or save the module(s) to a custom path
+  - Synthesize _from_ the algorithm(s) in mapFolding\theDao.py or from any source you select
+  - Use the existing transformation options
+  - Or create new ways of transforming the algorithm from its source to a new module
+  - Use your new module in synthesizeNumbaJob.py, above, as the source to create a mapShape-specific job module
+- mapFolding\theDao.py
+  - Modify the algorithms for initializing values, parallel computation, and/or sequential computation
+  - Use the modified algorithm(s) in synthesizeNumbaModules.py, above, to create Numba-optimized version(s)
+  - Then use a Numba-optimized version in synthesizeNumbaJob.py, above, to create a hyper-optimized version for a specific mapShape
+- mapFolding\theSSOT.py (and/or theSSOTnumba.py and/ or theSSOT____.py, if they exist)
+  - Modify broad settings or find functions to modify broad settings, such as data structures and their data types
+  - Create new settings or groups of settings
+- mapFolding\beDRY.py
+  - Functions to handle common tasks, such as parsing parameters or creating the `connectionGraph` for a mapShape (a Cartesian product decomposition)
+- mapFolding\someAssemblyRequired
+  - Create new transformations to optimize the algorithm, such as for JAX, CuPy, or CUDA
+  - (mapFolding\reference\jax.py has a once-functional JAX implementation, and synthesizeModuleJAX.py might be a useful starting point)
+
+## Map-folding Video
+
+~~This caused my neurosis:~~ I enjoyed the following video, which is what introduced me to map folding.
+
+"How Many Ways Can You Fold a Map?" by Physics for the Birds, 2024 November 13 ([BibTex](https://github.com/hunterhogan/mapFolding/blob/main/citations/Physics_for_the_Birds.bibtex) citation)
+
+[![How Many Ways Can You Fold a Map?](https://i.ytimg.com/vi/sfH9uIY3ln4/hq720.jpg)](https://www.youtube.com/watch?v=sfH9uIY3ln4)
+
+---
+
+## 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)
+
+[![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.4.1.dist-info/RECORD

@@ -0,0 +1,42 @@
+mapFolding/__init__.py,sha256=_YjoypHXmWLmEWwhFVgKO83Uf28ksesT9F73oJoAIPE,1323
+mapFolding/basecamp.py,sha256=v0VCF_Zgm_XBHcz4bqblsxfHwAxZKgenW6um77quWLk,3751
+mapFolding/beDRY.py,sha256=XVtLraG9VnC4yG2HkaFwZRh2td4ZHMjTQvnbcD_W130,17133
+mapFolding/oeis.py,sha256=3hv71o8bhckjY0nsSY5JTJ2LrpJcuhZ9j3mP6LWLIQc,11124
+mapFolding/theDao.py,sha256=SmyTbP1iwRAnpuq2ngdJKooXUA1_PR0VRHQ4fcJskMY,12713
+mapFolding/theSSOT.py,sha256=QrEMPREjEbt1H8HcrM2Nm_hv7JsFWRG3lHdUU0Jrv-w,10238
+mapFolding/theSSOTnumba.py,sha256=zGq2zlZZeuxiNSO2Fs_AqV6UhybJAJuDw-2lMVvDS2w,5133
+mapFolding/reference/flattened.py,sha256=S6D9wiFTlbeoetEqaMLOcA-R22BHOzjqPRujffNxxUM,14875
+mapFolding/reference/hunterNumba.py,sha256=jDS0ORHkIhcJ1rzA5hT49sZHKf3rgJOoGesUCcbKFFY,6054
+mapFolding/reference/irvineJavaPort.py,sha256=7GvBU0tnS6wpFgkYad3465do9jBQW-2bYvbCYyABPHM,3341
+mapFolding/reference/jax.py,sha256=7ji9YWia6Kof0cjcNdiS1GG1rMbC5SBjcyVr_07AeUk,13845
+mapFolding/reference/lunnan.py,sha256=iAbJELfW6RKNMdPcBY9b6rGQ-z1zoRf-1XCurCRMOo8,3951
+mapFolding/reference/lunnanNumpy.py,sha256=rwVP3WIDXimpAuaxhRIuBYU56nVDTKlfGiclw_FkgUU,3765
+mapFolding/reference/lunnanWhile.py,sha256=uRrMT23jTJvoQDlD_FzeIQe_pfMXJG6_bRvs7uhC8z0,3271
+mapFolding/reference/rotatedEntryPoint.py,sha256=USZY3n3zwhSE68ATscUuN66t1qShuEbMI790Gz9JFTw,9352
+mapFolding/reference/total_countPlus1vsPlusN.py,sha256=wpgay-uqPOBd64Z4Pg6tg40j7-4pzWHGMM6v0bnmjhE,6288
+mapFolding/someAssemblyRequired/__init__.py,sha256=wtec_hIz-AKz0_hGdXsWnCKTcCxdMV9-WK6SiIriAeU,396
+mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=nX8tghZClYt7zJd6RpZBXhE_h-CGRHOS17biqiEdf-o,855
+mapFolding/someAssemblyRequired/makeJob.py,sha256=c9sTRUK90snTCcXCvs86VKBH6z_nt3OVFjNs_WgCoIg,2422
+mapFolding/someAssemblyRequired/synthesizeModuleJAX.py,sha256=jatvtYhK5ZJK-YmCKATt7w3icFXXO79cZDAYVrU9bgA,1258
+mapFolding/someAssemblyRequired/synthesizeNumba.py,sha256=mPCjp4N-dOJRC4TvZGkqAqFKDWEPhWH9v0Cq5AWHlBA,17279
+mapFolding/someAssemblyRequired/synthesizeNumbaGeneralized.py,sha256=k8IaCT74ZPhHyra0MbCRdt_5k0Ov3vJgXlN5tbLVnf4,13998
+mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=2sKZgc5kyyz2KaoApcazj_37UgBqAkxORFeROWWU5tk,9038
+mapFolding/someAssemblyRequired/synthesizeNumbaModules.py,sha256=_iRXjMASB_BnYJeH8Rt7FlC-GE7lkZ1Hy292XTaUCu4,3785
+mapFolding/syntheticModules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/syntheticModules/numba_countInitialize.py,sha256=geHketfekZTgu5gbc8E3SShPmbW3gDybg5PCBpXdsa8,4274
+mapFolding/syntheticModules/numba_countParallel.py,sha256=kOI5PU90AExPvlWwU0BHVVFjlHlmUFp1KdtlmthQ71E,5517
+mapFolding/syntheticModules/numba_countSequential.py,sha256=zFFRv9oLtOih9TpbtARpVAPt-NfZxh0ygXuj-wfPjUg,3732
+mapFolding/syntheticModules/numba_doTheNeedful.py,sha256=6WuXKDMVa_C56dLlmXNvFl04MlU8-WVasqbAaxsgI-o,1368
+tests/__init__.py,sha256=eg9smg-6VblOr0kisM40CpGnuDtU2JgEEWGDTFVOlW8,57
+tests/conftest.py,sha256=7Ims3QcOzqBXu_k0kX9bt6PieC-OoIpc7OGxzdT2ELc,11826
+tests/test_computations.py,sha256=qBha4IggMfr6ZH06W3M66enTA6PWsx8vkDp5eqYFM9M,4765
+tests/test_oeis.py,sha256=31kdO1vnu2Lon43vM-YJVS4g40Ic03DWNER-cJcpxX4,4916
+tests/test_other.py,sha256=u0vINT5EyVsXTNTR2DZIMpWCg4FH471jjHLRzC2JX7U,8351
+tests/test_tasks.py,sha256=iq6_dh43JQkC2vAWXua0Xe915BKFGbvRJAkmbco854A,2389
+tests/test_types.py,sha256=58tmPG9WOeGGAQbdQK_h_7t4SnENnZugH4WXlI8-L-M,171
+mapFolding-0.4.1.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapFolding-0.4.1.dist-info/METADATA,sha256=iJiWfEzXVheLtyLLWT2BNis5xsisnhllS17hnPwiRws,7633
+mapFolding-0.4.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.4.1.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.4.1.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapFolding-0.4.1.dist-info/RECORD,,

tests/conftest.py

@@ -2,182 +2,306 @@
 
 # TODO learn how to run tests and coverage analysis without `env = ["NUMBA_DISABLE_JIT=1"]`
 
-from tests.conftest_tmpRegistry import (
-    pathCacheTesting,
-    pathDataSamples,
-    pathFilenameFoldsTotalTesting,
-    pathTempTesting,
-    setupTeardownTestData,
-)
-from tests.conftest_uniformTests import (
-    uniformTestMessage,
-    standardizedEqualTo,
-    standardizedSystemExit,
-)
 from mapFolding import *
-from mapFolding import basecamp
-from mapFolding import getAlgorithmCallable, getDispatcherCallable
+from mapFolding import basecamp, getAlgorithmDispatcher, getDispatcherCallable
 from mapFolding.beDRY import *
-from mapFolding.oeis import _getFilenameOEISbFile, _getOEISidValues, _getOEISidInformation
+from mapFolding.someAssemblyRequired import *
+from mapFolding.oeis import _getFilenameOEISbFile, _getOEISidInformation, _getOEISidValues
 from mapFolding.oeis import *
+from types import ModuleType
+from typing import Any, Callable, ContextManager, Dict, Generator, List, Literal, NoReturn, Optional, Sequence, Set, Tuple, Type, Union
 from Z0Z_tools.pytestForYourUse import PytestFor_defineConcurrencyLimit, PytestFor_intInnit, PytestFor_oopsieKwargsie
-from typing import Any, Callable, ContextManager, Dict, Generator, List, Optional, Sequence, Set, Tuple, Type, Union
 import pathlib
 import pytest
 import random
+import shutil
 import unittest.mock
+import uuid
+
+# SSOT for test data paths and filenames
+pathDataSamples = pathlib.Path("tests/dataSamples")
+# NOTE `tmp` is not a diminutive form of temporary: it signals a technical term. And "temp" is strongly disfavored.
+pathTmpRoot = pathDataSamples / "tmp"
+
+# The registrar maintains the register of temp files
+registerOfTemporaryFilesystemObjects: Set[pathlib.Path] = set()
+
+def registrarRecordsTmpObject(path: pathlib.Path) -> None:
+	"""The registrar adds a tmp file to the register."""
+	registerOfTemporaryFilesystemObjects.add(path)
+
+def registrarDeletesTmpObjects() -> None:
+	"""The registrar cleans up tmp files in the register."""
+	for pathTmp in sorted(registerOfTemporaryFilesystemObjects, reverse=True):
+		try:
+			if pathTmp.is_file():
+				pathTmp.unlink(missing_ok=True)
+			elif pathTmp.is_dir():
+				shutil.rmtree(pathTmp, ignore_errors=True)
+		except Exception as ERRORmessage:
+			print(f"Warning: Failed to clean up {pathTmp}: {ERRORmessage}")
+	registerOfTemporaryFilesystemObjects.clear()
+
+@pytest.fixture(scope="session", autouse=True)
+def setupTeardownTmpObjects() -> Generator[None, None, None]:
+	"""Auto-fixture to setup test data directories and cleanup after."""
+	pathDataSamples.mkdir(exist_ok=True)
+	pathTmpRoot.mkdir(exist_ok=True)
+	yield
+	registrarDeletesTmpObjects()
+
+@pytest.fixture
+def pathTmpTesting(request: pytest.FixtureRequest) -> pathlib.Path:
+	# "Z0Z_" ensures the directory name does not start with a number, which would make it an invalid Python identifier
+	pathTmp = pathTmpRoot / ("Z0Z_" + str(uuid.uuid4().hex))
+	pathTmp.mkdir(parents=True, exist_ok=False)
+
+	registrarRecordsTmpObject(pathTmp)
+	return pathTmp
+
+@pytest.fixture
+def pathFilenameTmpTesting(request: pytest.FixtureRequest) -> pathlib.Path:
+	try:
+		extension = request.param
+	except AttributeError:
+		extension = ".txt"
+
+	# "Z0Z_" ensures the name does not start with a number, which would make it an invalid Python identifier
+	uuidHex = uuid.uuid4().hex
+	subpath = "Z0Z_" + uuidHex[0:-8]
+	filenameStem = "Z0Z_" + uuidHex[-8:None]
+
+	pathFilenameTmp = pathlib.Path(pathTmpRoot, subpath, filenameStem + extension)
+	pathFilenameTmp.parent.mkdir(parents=True, exist_ok=False)
+
+	registrarRecordsTmpObject(pathFilenameTmp)
+	return pathFilenameTmp
+
+@pytest.fixture
+def pathCacheTesting(pathTmpTesting: pathlib.Path) -> Generator[pathlib.Path, Any, None]:
+	"""Temporarily replace the OEIS cache directory with a test directory."""
+	from mapFolding import oeis as there_must_be_a_better_way
+	pathCacheOriginal = there_must_be_a_better_way._pathCache
+	there_must_be_a_better_way._pathCache = pathTmpTesting
+	yield pathTmpTesting
+	there_must_be_a_better_way._pathCache = pathCacheOriginal
+
+@pytest.fixture
+def pathFilenameFoldsTotalTesting(pathTmpTesting: pathlib.Path) -> pathlib.Path:
+	return pathTmpTesting.joinpath("foldsTotalTest.txt")
 
 def makeDictionaryFoldsTotalKnown() -> Dict[Tuple[int,...], int]:
-    """Returns a dictionary mapping dimension tuples to their known folding totals."""
-    dictionaryMapDimensionsToFoldsTotalKnown: Dict[Tuple[int, ...], int] = {}
-
-    for settings in settingsOEIS.values():
-        sequence = settings['valuesKnown']
-
-        for n, foldingsTotal in sequence.items():
-            dimensions = settings['getMapShape'](n)
-            dimensions.sort()
-            dictionaryMapDimensionsToFoldsTotalKnown[tuple(dimensions)] = foldingsTotal
-
-    # Are we in a place that has jobs?
-    pathJobDEFAULT = getPathJobRootDEFAULT()
-    if pathJobDEFAULT.exists():
-        # Are there foldsTotal files?
-        for pathFilenameFoldsTotal in pathJobDEFAULT.rglob('*.foldsTotal'):
-            if pathFilenameFoldsTotal.is_file():
-                try:
-                    listDimensions = eval(pathFilenameFoldsTotal.stem)
-                except Exception:
-                    continue
-                # Are the dimensions in the dictionary?
-                if isinstance(listDimensions, list) and all(isinstance(dimension, int) for dimension in listDimensions):
-                    listDimensions.sort()
-                    if tuple(listDimensions) in dictionaryMapDimensionsToFoldsTotalKnown:
-                        continue
-                    # Are the contents a reasonably large integer?
-                    try:
-                        foldsTotal = pathFilenameFoldsTotal.read_text()
-                    except Exception:
-                        continue
-                    # Why did I sincerely believe this would only be three lines of code?
-                    if foldsTotal.isdigit():
-                        foldsTotalInteger = int(foldsTotal)
-                        if foldsTotalInteger > 85109616 * 10**3:
-                            # You made it this far, so fuck it: put it in the dictionary
-                            dictionaryMapDimensionsToFoldsTotalKnown[tuple(listDimensions)] = foldsTotalInteger
-                        dictionaryMapDimensionsToFoldsTotalKnown[tuple(listDimensions)] = foldsTotalInteger
-                    # The sunk-costs fallacy claims another victim!
-
-    return dictionaryMapDimensionsToFoldsTotalKnown
+	"""Returns a dictionary mapping dimension tuples to their known folding totals."""
+	dictionaryMapDimensionsToFoldsTotalKnown: Dict[Tuple[int, ...], int] = {}
+
+	for settings in settingsOEIS.values():
+		sequence = settings['valuesKnown']
+
+		for n, foldingsTotal in sequence.items():
+			dimensions = settings['getMapShape'](n)
+			dimensions.sort()
+			dictionaryMapDimensionsToFoldsTotalKnown[tuple(dimensions)] = foldingsTotal
+
+	# Are we in a place that has jobs?
+	pathJobDEFAULT = getPathJobRootDEFAULT()
+	if pathJobDEFAULT.exists():
+		# Are there foldsTotal files?
+		for pathFilenameFoldsTotal in pathJobDEFAULT.rglob('*.foldsTotal'):
+			if pathFilenameFoldsTotal.is_file():
+				try:
+					listDimensions = eval(pathFilenameFoldsTotal.stem)
+				except Exception:
+					continue
+				# Are the dimensions in the dictionary?
+				if isinstance(listDimensions, list) and all(isinstance(dimension, int) for dimension in listDimensions):
+					listDimensions.sort()
+					if tuple(listDimensions) in dictionaryMapDimensionsToFoldsTotalKnown:
+						continue
+					# Are the contents a reasonably large integer?
+					try:
+						foldsTotal = pathFilenameFoldsTotal.read_text()
+					except Exception:
+						continue
+					# Why did I sincerely believe this would only be three lines of code?
+					if foldsTotal.isdigit():
+						foldsTotalInteger = int(foldsTotal)
+						if foldsTotalInteger > 85109616 * 10**3:
+							# You made it this far, so fuck it: put it in the dictionary
+							dictionaryMapDimensionsToFoldsTotalKnown[tuple(listDimensions)] = foldsTotalInteger
+						dictionaryMapDimensionsToFoldsTotalKnown[tuple(listDimensions)] = foldsTotalInteger
+					# The sunk-costs fallacy claims another victim!
+
+	return dictionaryMapDimensionsToFoldsTotalKnown
 
 """
 Section: Fixtures"""
 
 @pytest.fixture(autouse=True)
 def setupWarningsAsErrors() -> Generator[None, Any, None]:
-    """Convert all warnings to errors for all tests."""
-    import warnings
-    warnings.filterwarnings("error")
-    yield
-    warnings.resetwarnings()
+	"""Convert all warnings to errors for all tests."""
+	import warnings
+	warnings.filterwarnings("error")
+	yield
+	warnings.resetwarnings()
 
 @pytest.fixture
 def foldsTotalKnown() -> Dict[Tuple[int,...], int]:
-    """Returns a dictionary mapping dimension tuples to their known folding totals.
-    NOTE I am not convinced this is the best way to do this.
-    Advantage: I call `makeDictionaryFoldsTotalKnown()` from modules other than test modules.
-    Preference: I _think_ I would prefer a SSOT function available to any module
-    similar to `foldsTotalKnown = getFoldsTotalKnown(listDimensions)`."""
-    return makeDictionaryFoldsTotalKnown()
+	"""Returns a dictionary mapping dimension tuples to their known folding totals.
+	NOTE I am not convinced this is the best way to do this.
+	Advantage: I call `makeDictionaryFoldsTotalKnown()` from modules other than test modules.
+	Preference: I _think_ I would prefer a SSOT function available to any module
+	similar to `foldsTotalKnown = getFoldsTotalKnown(listDimensions)`."""
+	return makeDictionaryFoldsTotalKnown()
 
 @pytest.fixture
 def listDimensionsTestCountFolds(oeisID: str) -> List[int]:
-    """For each `oeisID` 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]['valuesTestValidation'])
-        if n < 2:
-            continue
-        listDimensionsCandidate = settingsOEIS[oeisID]['getMapShape'](n)
-
-        try:
-            return validateListDimensions(listDimensionsCandidate)
-        except (ValueError, NotImplementedError):
-            pass
+	"""For each `oeisID` 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]['valuesTestValidation'])
+		if n < 2:
+			continue
+		listDimensionsCandidate = settingsOEIS[oeisID]['getMapShape'](n)
+
+		try:
+			return validateListDimensions(listDimensionsCandidate)
+		except (ValueError, NotImplementedError):
+			pass
 
 @pytest.fixture
 def listDimensionsTestFunctionality(oeisID_1random: str) -> List[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."""
-    while True:
-        n = random.choice(settingsOEIS[oeisID_1random]['valuesTestValidation'])
-        if n < 2:
-            continue
-        listDimensionsCandidate = settingsOEIS[oeisID_1random]['getMapShape'](n)
-
-        try:
-            return validateListDimensions(listDimensionsCandidate)
-        except (ValueError, NotImplementedError):
-            pass
+	"""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."""
+	while True:
+		n = random.choice(settingsOEIS[oeisID_1random]['valuesTestValidation'])
+		if n < 2:
+			continue
+		listDimensionsCandidate = settingsOEIS[oeisID_1random]['getMapShape'](n)
+
+		try:
+			return validateListDimensions(listDimensionsCandidate)
+		except (ValueError, NotImplementedError):
+			pass
 
 @pytest.fixture
 def listDimensionsTestParallelization(oeisID: str) -> List[int]:
-    """For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestParallelization`"""
-    n = random.choice(settingsOEIS[oeisID]['valuesTestParallelization'])
-    return settingsOEIS[oeisID]['getMapShape'](n)
+	"""For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestParallelization`"""
+	n = random.choice(settingsOEIS[oeisID]['valuesTestParallelization'])
+	return settingsOEIS[oeisID]['getMapShape'](n)
 
 @pytest.fixture
 def mockBenchmarkTimer() -> Generator[unittest.mock.MagicMock | unittest.mock.AsyncMock, Any, None]:
-    """Mock time.perf_counter_ns for consistent benchmark timing."""
-    with unittest.mock.patch('time.perf_counter_ns') as mockTimer:
-        mockTimer.side_effect = [0, 1e9]  # Start and end times for 1 second
-        yield mockTimer
+	"""Mock time.perf_counter_ns for consistent benchmark timing."""
+	with unittest.mock.patch('time.perf_counter_ns') as mockTimer:
+		mockTimer.side_effect = [0, 1e9]  # Start and end times for 1 second
+		yield mockTimer
 
 @pytest.fixture
 def mockFoldingFunction() -> Callable[..., Callable[..., None]]:
-    """Creates a mock function that simulates _countFolds behavior."""
-    def make_mock(foldsValue: int, listDimensions: List[int]) -> Callable[..., None]:
-        mock_array = makeDataContainer(2)
-        mock_array[0] = foldsValue
-        mock_array[-1] = getLeavesTotal(listDimensions)
+	"""Creates a mock function that simulates _countFolds behavior."""
+	def make_mock(foldsValue: int, listDimensions: List[int]) -> Callable[..., None]:
+		mock_array = makeDataContainer(2)
+		mock_array[0] = foldsValue
+		mock_array[-1] = getLeavesTotal(listDimensions)
 
-        def mock_countFolds(**keywordArguments: Any) -> None:
-            keywordArguments['foldGroups'][:] = mock_array
-            return None
+		def mock_countFolds(**keywordArguments: Any) -> None:
+			keywordArguments['foldGroups'][:] = mock_array
+			return None
 
-        return mock_countFolds
-    return make_mock
+		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 = getDispatcherCallable()
-        return unittest.mock.patch(
-            f"{dispatcherCallable.__module__}.{dispatcherCallable.__name__}",
-            side_effect=mockFunction
-        )
-    return wrapper
+	"""Context manager for mocking dispatcher callable."""
+	def wrapper(mockFunction: Any) -> ContextManager[Any]:
+		dispatcherCallable = getDispatcherCallable()
+		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
+	return request.param
 
 @pytest.fixture
 def oeisID_1random() -> str:
-    """Return one random valid OEIS ID."""
-    return random.choice(oeisIDsImplemented)
+	"""Return one random valid OEIS ID."""
+	return random.choice(oeisIDsImplemented)
+
+@pytest.fixture
+def useThisDispatcher():
+	"""A fixture providing a context manager for temporarily replacing the dispatcher.
+
+	Returns
+		A context manager for patching the dispatcher
+	"""
+	dispatcherOriginal = basecamp.getDispatcherCallable
+
+	def patchDispatcher(callableTarget: Callable) -> None:
+		def callableParameterized(*arguments: Any, **keywordArguments: Any) -> Callable:
+			return callableTarget
+		basecamp.getDispatcherCallable = callableParameterized
+
+	yield patchDispatcher
+	basecamp.getDispatcherCallable = dispatcherOriginal
 
 @pytest.fixture
-def useAlgorithmDirectly() -> Generator[None, Any, None]:
-    """Temporarily patches getDispatcherCallable to return the algorithm source directly."""
-    original_dispatcher = basecamp.getDispatcherCallable
+def useAlgorithmSourceDispatcher(useThisDispatcher: Callable) -> Generator[None, None, None]:
+	"""Temporarily patches getDispatcherCallable to return the algorithm dispatcher."""
+	useThisDispatcher(getAlgorithmDispatcher())
+	yield
+
+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"
+			f"Expected: {expected}\n"
+			f"Got: {actual}")
+
+def standardizedEqualTo(expected: Any, functionTarget: Callable, *arguments: Any) -> None:
+	"""Template for tests expecting an error."""
+	if type(expected) is Type[Exception]:
+		messageExpected = expected.__name__
+	else:
+		messageExpected = expected
+
+	try:
+		messageActual = actual = functionTarget(*arguments)
+	except Exception as actualError:
+		messageActual = type(actualError).__name__
+		actual = type(actualError)
+
+	assert actual == expected, uniformTestMessage(messageExpected, messageActual, functionTarget.__name__, *arguments)
+
+def standardizedSystemExit(expected: Union[str, int, Sequence[int]], functionTarget: Callable, *arguments: Any) -> None:
+	"""Template for tests expecting SystemExit.
 
-    # Patch the function at module level
-    basecamp.getDispatcherCallable = getAlgorithmCallable
+	Parameters
+		expected: Exit code expectation:
+			- "error": any non-zero exit code
+			- "nonError": specifically zero exit code
+			- int: exact exit code match
+			- Sequence[int]: exit code must be one of these values
+		functionTarget: The function to test
+		arguments: Arguments to pass to the function
+	"""
+	with pytest.raises(SystemExit) as exitInfo:
+		functionTarget(*arguments)
 
-    yield
+	exitCode = exitInfo.value.code
 
-    # Restore original function
-    basecamp.getDispatcherCallable = original_dispatcher
+	if expected == "error":
+		assert exitCode != 0, \
+			f"Expected error exit (non-zero) but got code {exitCode}"
+	elif expected == "nonError":
+		assert exitCode == 0, \
+			f"Expected non-error exit (0) but got code {exitCode}"
+	elif isinstance(expected, (list, tuple)):
+		assert exitCode in expected, \
+			f"Expected exit code to be one of {expected} but got {exitCode}"
+	else:
+		assert exitCode == expected, \
+			f"Expected exit code {expected} but got {exitCode}"