mapFolding 0.3.11__py3-none-any.whl → 0.4.0__py3-none-any.whl

mapFolding-0.4.0.dist-info/METADATA

@@ -0,0 +1,122 @@
+Metadata-Version: 2.2
+Name: mapFolding
+Version: 0.4.0
+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,folding,map folding,OEIS,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
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+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: synthesizemodules
+Requires-Dist: autoflake; extra == "synthesizemodules"
+Requires-Dist: more_itertools; extra == "synthesizemodules"
+Requires-Dist: python_minifier; extra == "synthesizemodules"
+Provides-Extra: testing
+Requires-Dist: mypy; extra == "testing"
+Requires-Dist: pytest-cov; extra == "testing"
+Requires-Dist: pytest-env; extra == "testing"
+Requires-Dist: pytest-mypy; extra == "testing"
+Requires-Dist: pytest-xdist; extra == "testing"
+Requires-Dist: pytest; 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.
+
+## 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.0.dist-info/RECORD

@@ -0,0 +1,41 @@
+mapFolding/__init__.py,sha256=6HgDJ2_-lnTMVwXDhTs36MgQT6Ph0kYVvuvkeUP2u9w,1321
+mapFolding/basecamp.py,sha256=v0VCF_Zgm_XBHcz4bqblsxfHwAxZKgenW6um77quWLk,3751
+mapFolding/beDRY.py,sha256=XVtLraG9VnC4yG2HkaFwZRh2td4ZHMjTQvnbcD_W130,17133
+mapFolding/oeis.py,sha256=rTMK4aQXxudmUGS-RkzikmSIPLdottVgJHKwY0atZqg,11120
+mapFolding/theDao.py,sha256=ktYQSsF6pQrWA0bj6UVbvTsWgZP8mlEj1JKGQeqeFuI,12701
+mapFolding/theSSOT.py,sha256=anbFOL2daNLcy9SuO_4EyFFlPsnKSpkvyO11Zf4QCoU,10174
+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=nqW7FcV65IS0tctqzzJ0MDex_z24es8OGYApzKcx1Ys,144
+mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=nX8tghZClYt7zJd6RpZBXhE_h-CGRHOS17biqiEdf-o,855
+mapFolding/someAssemblyRequired/makeJob.py,sha256=TZBJHgAEJ6c5XU4DHuyQgKOY-nf19Fvvoicyzn2huG0,2436
+mapFolding/someAssemblyRequired/synthesizeModuleJAX.py,sha256=jatvtYhK5ZJK-YmCKATt7w3icFXXO79cZDAYVrU9bgA,1258
+mapFolding/someAssemblyRequired/synthesizeNumba.py,sha256=949ZrnKy8rFsgZy8I5e82RMoFdCnVM9JML1l7lW-rOQ,17226
+mapFolding/someAssemblyRequired/synthesizeNumbaGeneralized.py,sha256=9Xa-ftqDScsvhs-2zq5vsJ6LofCdaz1hMUbKPF49vPE,16080
+mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=5q8ROqNHODy_WacVZq0vu4AHjqfwuS6mOmRZQWQ_XWE,8128
+mapFolding/someAssemblyRequired/synthesizeNumbaModules.py,sha256=1V8tF-pjcmpFIywZuC-_i1EN3KsQAvI0SnIlzlXxDCs,3731
+mapFolding/syntheticModules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/syntheticModules/numba_countInitialize.py,sha256=6-OlRBCEAKstJm-E0cs4VjPolYxiz9zSNvUGU6BRoTg,4274
+mapFolding/syntheticModules/numba_countParallel.py,sha256=64HHCOPOnsw7bSuLClaWpeH6C8D1aksZSDj8b_xQJec,5517
+mapFolding/syntheticModules/numba_countSequential.py,sha256=1_V4cIqiqKO2lvvc5IyNEX3ElMJs3ZiWB3HUU3sjdMI,3732
+mapFolding/syntheticModules/numba_doTheNeedful.py,sha256=koAKvwn5gUO4gVoeXaA12qguZAYz_Tso42xAH9UVw8o,1368
+tests/__init__.py,sha256=eg9smg-6VblOr0kisM40CpGnuDtU2JgEEWGDTFVOlW8,57
+tests/conftest.py,sha256=gZTZlqW814yucdRhtSV6IsfAM67QgoW5rkdvlveyEFQ,11095
+tests/test_oeis.py,sha256=72mL0MtBEYCh58t_qP8qvt6s9kV1fDk4Z9xVEapaapQ,5367
+tests/test_other.py,sha256=fg7t8zW7zG26mw7d06E5cLfirhDrCjelMjwFAZ0C2KM,8433
+tests/test_tasks.py,sha256=jjp-PzxrXMG9L7BBP_2NYLel5xlm-I552wLu3c_a4rw,2741
+tests/test_types.py,sha256=58tmPG9WOeGGAQbdQK_h_7t4SnENnZugH4WXlI8-L-M,171
+mapFolding-0.4.0.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapFolding-0.4.0.dist-info/METADATA,sha256=H82VPfUNoVNwkEeSSDHSD6JzB05x1vEl7ADd1y-7Ht8,5241
+mapFolding-0.4.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.4.0.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.4.0.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapFolding-0.4.0.dist-info/RECORD,,

tests/conftest.py

@@ -2,182 +2,292 @@
 
 # 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, getAlgorithmCallable, getDispatcherCallable
 from mapFolding.beDRY import *
-from mapFolding.oeis import _getFilenameOEISbFile, _getOEISidValues, _getOEISidInformation
+from mapFolding.oeis import _getFilenameOEISbFile, _getOEISidInformation, _getOEISidValues
 from mapFolding.oeis import *
-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
+from Z0Z_tools.pytestForYourUse import PytestFor_defineConcurrencyLimit, PytestFor_intInnit, PytestFor_oopsieKwargsie
 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:
+	pathTmp = pathTmpRoot / 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"
+
+	uuidHex = uuid.uuid4().hex
+	subpath = uuidHex[0:-8]
+	filenameStem = 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 useAlgorithmDirectly() -> Generator[None, Any, None]:
-    """Temporarily patches getDispatcherCallable to return the algorithm source directly."""
-    original_dispatcher = basecamp.getDispatcherCallable
+	"""Temporarily patches getDispatcherCallable to return the algorithm source directly."""
+	original_dispatcher = basecamp.getDispatcherCallable
+
+	# Patch the function at module level
+	basecamp.getDispatcherCallable = getAlgorithmCallable
+
+	yield
+
+	# Restore original function
+	basecamp.getDispatcherCallable = original_dispatcher
+
+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}"