mapFolding 0.4.2__py3-none-any.whl → 0.5.0__py3-none-any.whl

mapFolding/theSSOTdatatypes.py

@@ -0,0 +1,166 @@
+from collections import defaultdict
+from typing import Any, cast, Final, TYPE_CHECKING
+import enum
+import numba
+import numpy
+
+try:
+	from typing import NotRequired
+except Exception:
+	from typing_extensions import NotRequired # type: ignore
+
+if TYPE_CHECKING:
+	from typing import TypedDict
+else:
+	TypedDict = dict
+
+class EnumIndices(enum.IntEnum):
+	@staticmethod
+	def _generate_next_value_(name: str, start: int, count: int, last_values: list[Any]) -> int:
+		"""0-indexed."""
+		return count
+
+	def __index__(self) -> int:
+		"""Adapt enum to the ultra-rare event of indexing a NumPy 'ndarray', which is not the
+		same as `array.array`. See NumPy.org; I think it will be very popular someday."""
+		return self.value
+
+class indexMy(EnumIndices):
+	"""Indices for scalar values."""
+	dimensionsTotal 		= enum.auto()
+	dimensionsUnconstrained = enum.auto()
+	gap1ndex				= enum.auto()
+	gap1ndexCeiling 		= enum.auto()
+	indexDimension 			= enum.auto()
+	indexLeaf 				= enum.auto()
+	indexMiniGap 			= enum.auto()
+	leaf1ndex 				= enum.auto()
+	leafConnectee 			= enum.auto()
+	taskDivisions 			= enum.auto()
+	taskIndex 				= enum.auto()
+
+class indexTrack(EnumIndices):
+	"""Indices for state tracking array."""
+	leafAbove				= enum.auto()
+	leafBelow				= enum.auto()
+	countDimensionsGapped	= enum.auto()
+	gapRangeStart			= enum.auto()
+
+_datatypeDefault: Final[dict[str, str]] = {
+	'elephino': 'uint16',
+	'foldsTotal': 'int64',
+	'leavesTotal': 'uint16',
+}
+_datatypeModule = ''
+_datatypeModuleDEFAULT: Final[str] = 'numpy'
+
+_datatype: dict[str, str] = defaultdict(str)
+
+def reportDatatypeLimit(identifier: str, datatype: str, sourGrapes: bool | None = False) -> str:
+	global _datatype
+	if not _datatype[identifier]:
+		_datatype[identifier] = datatype
+	elif _datatype[identifier] == datatype:
+		pass
+	elif sourGrapes:
+		raise Exception(f"Datatype is '{_datatype[identifier]}' not '{datatype}', so you can take your ball and go home.")
+	return _datatype[identifier]
+
+def setDatatypeModule(datatypeModule: str, sourGrapes: bool | None = False) -> str:
+	global _datatypeModule
+	if not _datatypeModule:
+		_datatypeModule = datatypeModule
+	elif _datatypeModule == datatypeModule:
+		pass
+	elif sourGrapes:
+		raise Exception(f"Datatype module is '{_datatypeModule}' not '{datatypeModule}', so you can take your ball and go home.")
+	return _datatypeModule
+
+def setDatatypeElephino(datatype: str, sourGrapes: bool | None = False) -> str:
+	return reportDatatypeLimit('elephino', datatype, sourGrapes)
+
+def setDatatypeFoldsTotal(datatype: str, sourGrapes: bool | None = False) -> str:
+	return reportDatatypeLimit('foldsTotal', datatype, sourGrapes)
+
+def setDatatypeLeavesTotal(datatype: str, sourGrapes: bool | None = False) -> str:
+	return reportDatatypeLimit('leavesTotal', datatype, sourGrapes)
+
+def _get_datatype(identifier: str) -> str:
+	global _datatype
+	if not _datatype[identifier]:
+		if identifier in indexMy._member_names_:
+			_datatype[identifier] = _datatypeDefault.get(identifier) or _get_datatype('elephino')
+		elif identifier in indexTrack._member_names_:
+			_datatype[identifier] = _datatypeDefault.get(identifier) or _get_datatype('elephino')
+		else:
+			_datatype[identifier] = _datatypeDefault.get(identifier) or _get_datatype('foldsTotal')
+	return _datatype[identifier]
+
+def getDatatypeModule() -> str:
+	global _datatypeModule
+	if not _datatypeModule:
+		_datatypeModule = _datatypeModuleDEFAULT
+	return _datatypeModule
+
+def setInStone(identifier: str) -> type[Any]:
+	datatypeModule = getDatatypeModule()
+	datatypeStr = _get_datatype(identifier)
+	return cast(type[Any], getattr(eval(datatypeModule), datatypeStr))
+
+def hackSSOTdtype(identifier: str) -> type[Any]:
+	_hackSSOTdtype={
+	'connectionGraph': 	'dtypeLeavesTotal',
+	'dtypeElephino': 	'dtypeElephino',
+	'dtypeFoldsTotal': 	'dtypeFoldsTotal',
+	'dtypeLeavesTotal': 'dtypeLeavesTotal',
+	'foldGroups': 		'dtypeFoldsTotal',
+	'gapsWhere': 		'dtypeLeavesTotal',
+	'mapShape': 		'dtypeLeavesTotal',
+	'my': 				'dtypeElephino',
+	'track': 			'dtypeElephino',
+	}
+	RubeGoldBerg = _hackSSOTdtype[identifier]
+	if RubeGoldBerg == 'dtypeElephino':
+		return setInStone('elephino')
+	elif RubeGoldBerg == 'dtypeFoldsTotal':
+		return setInStone('foldsTotal')
+	elif RubeGoldBerg == 'dtypeLeavesTotal':
+		return setInStone('leavesTotal')
+	raise Exception("Dude, you forgot to set a value in `hackSSOTdtype`.")
+
+def hackSSOTdatatype(identifier: str) -> str:
+	_hackSSOTdatatype={
+	'connectionGraph':	 		'datatypeLeavesTotal',
+	'countDimensionsGapped': 	'datatypeLeavesTotal',
+	'datatypeElephino': 		'datatypeElephino',
+	'datatypeFoldsTotal': 		'datatypeFoldsTotal',
+	'datatypeLeavesTotal': 		'datatypeLeavesTotal',
+	'dimensionsTotal': 			'datatypeLeavesTotal',
+	'dimensionsUnconstrained':	'datatypeLeavesTotal',
+	'foldGroups': 				'datatypeFoldsTotal',
+	'gap1ndex': 				'datatypeLeavesTotal',
+	'gap1ndexCeiling': 			'datatypeElephino',
+	'gapRangeStart': 			'datatypeElephino',
+	'gapsWhere': 				'datatypeLeavesTotal',
+	'groupsOfFolds': 			'datatypeFoldsTotal',
+	'indexDimension': 			'datatypeLeavesTotal',
+	'indexLeaf': 				'datatypeLeavesTotal',
+	'indexMiniGap': 			'datatypeElephino',
+	'leaf1ndex': 				'datatypeLeavesTotal',
+	'leafAbove': 				'datatypeLeavesTotal',
+	'leafBelow': 				'datatypeLeavesTotal',
+	'leafConnectee': 			'datatypeLeavesTotal',
+	'mapShape': 				'datatypeLeavesTotal',
+	'my':	 					'datatypeElephino',
+	'taskDivisions': 			'datatypeLeavesTotal',
+	'taskIndex': 				'datatypeLeavesTotal',
+	'track':	 				'datatypeElephino',
+	}
+	RubeGoldBerg = _hackSSOTdatatype[identifier]
+	if RubeGoldBerg == 'datatypeElephino':
+		return _get_datatype('elephino')
+	elif RubeGoldBerg == 'datatypeFoldsTotal':
+		return _get_datatype('foldsTotal')
+	elif RubeGoldBerg == 'datatypeLeavesTotal':
+		return _get_datatype('leavesTotal')
+	raise Exception("Dude, you forgot to set a value in `hackSSOTdatatype`.")

{mapFolding-0.4.2.dist-info → mapFolding-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.4.2
+Version: 0.5.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
@@ -39,6 +39,7 @@ 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: pyupgrade; extra == "testing"
 Requires-Dist: updateCitation; extra == "testing"
 
 # mapFolding: Algorithms for enumerating distinct map/stamp folding patterns 🗺️

mapFolding-0.5.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+mapFolding/__init__.py,sha256=AQA9ypsiV8cDUCvWdM64kFhO9LaKFvAuSEw03jiI7ao,1358
+mapFolding/basecamp.py,sha256=f6Z_KJ1iGV5a3YBDsxS0m7RojYABYlR4kb-dvKW8CAs,3703
+mapFolding/beDRY.py,sha256=ViKLdomPYXD4o86BZwWgT0qPQNKqdtAZ74YoKC9Kgjg,16793
+mapFolding/oeis.py,sha256=Jak0vOfS_gGTXH6xBI7NTUp4Clluvj792E5HNFDDt6U,11149
+mapFolding/theDao.py,sha256=64dlLhrdtNbZAXMbqcZhGAE0ZwgqYRt8nT1on46J-cc,12611
+mapFolding/theSSOT.py,sha256=tcEbPQLmvRWfIyuR0NpeY0Vm6l6L1dUJFyFZjbDo2Gs,6026
+mapFolding/theSSOTdatatypes.py,sha256=OoB9hVfedQejRPxkP-dgLMHS-vqw_0imBvMLBuyLlg0,5829
+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=neb_sFvYMx6dlZxKVmwGjKNrEsK0XaHyE1AJD9S9-nA,2408
+mapFolding/someAssemblyRequired/synthesizeModuleJAX.py,sha256=21Wos8ynlly577EUDqWbbNc9R1qc19r5ysWaz86bCvg,1210
+mapFolding/someAssemblyRequired/synthesizeNumba.py,sha256=6bVbZMnszgz5J81KF-_LQyi6Sw9SwUBD-k8u-mFKADo,16940
+mapFolding/someAssemblyRequired/synthesizeNumbaGeneralized.py,sha256=vu6oYqoZGLNzbd3i8H9B2cEtL9bM1dhmbIpcJeF1NKE,16666
+mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=YRFLuEWcE7Fz4D7vgEwwof5xsrTRY2tIFl69GrFYke8,9050
+mapFolding/someAssemblyRequired/synthesizeNumbaModules.py,sha256=3oUCPU4nnfynhEqSFqIC8BZ1x0lXK0_0_o-hIx8MCPw,5504
+mapFolding/syntheticModules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/syntheticModules/numbaCount.py,sha256=447sbrCINu6wMfpJENguUyAxd6Vej3w98WzyVelz8eg,12900
+mapFolding/syntheticModules/numba_doTheNeedful.py,sha256=8utsCDlcIvOlrjGugaD6DgecoDICIo5_BKhkYtwv-74,1150
+tests/__init__.py,sha256=eg9smg-6VblOr0kisM40CpGnuDtU2JgEEWGDTFVOlW8,57
+tests/conftest.py,sha256=rorOpl3Q1ksGQB-8UyLdUDkYBl9O3M19CvOKrnnzr-4,12296
+tests/test_computations.py,sha256=67dcIj94VM69m912cY1L8HuqnXWl9NFVNhjx3zRNjvA,2831
+tests/test_oeis.py,sha256=4EPJrd359kO019e6whDnERU-gnvMeOeUsHFgor7bA1Y,4686
+tests/test_other.py,sha256=x34TGMWY7YmVtTduC_hlmISMVYemcx_z8_UcMcaNyIk,8375
+tests/test_tasks.py,sha256=J8CET4Z-SYZGdy1-nj-pvVqMl6ujTXJR5ZCYkU4gbUc,2389
+mapFolding-0.5.0.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapFolding-0.5.0.dist-info/METADATA,sha256=rLrgAmUzYgyLQV_mh749XXhiD1RLrol0iHXZpA_10DU,7678
+mapFolding-0.5.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.5.0.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.5.0.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapFolding-0.5.0.dist-info/RECORD,,

tests/conftest.py

@@ -2,16 +2,45 @@
 
 # TODO learn how to run tests and coverage analysis without `env = ["NUMBA_DISABLE_JIT=1"]`
 
-from mapFolding import *
-from mapFolding import basecamp, getAlgorithmDispatcher, getDispatcherCallable
-from mapFolding.beDRY import *
-from mapFolding.someAssemblyRequired import *
-from mapFolding.oeis import _getFilenameOEISbFile, _getOEISidInformation, _getOEISidValues
-from mapFolding.oeis import *
+from collections.abc import Callable, Generator, Sequence
+from mapFolding import (
+	getAlgorithmDispatcher,
+	getDispatcherCallable,
+	countFolds,
+	getPathFilenameFoldsTotal,
+	oeisIDfor_n,
+	saveFoldsTotal,
+	hackSSOTdtype,
+	clearOEIScache,
+	getOEISids,
+)
+from mapFolding import basecamp
+from mapFolding.beDRY import (
+	getLeavesTotal,
+	validateListDimensions,
+	makeDataContainer,
+	parseDimensions,
+	setCPUlimit,
+	makeConnectionGraph,
+	getTaskDivisions,
+)
+from mapFolding.oeis import (
+	oeisIDsImplemented,
+	settingsOEIS,
+	validateOEISid,
+	getOEISidValues,
+	OEIS_for_n,
+)
+from mapFolding.someAssemblyRequired import (
+	makeFlowNumbaOptimized,
+	youOughtaKnow,
+	writeJobNumba,
+)
+from pathlib import Path
 from types import ModuleType
-from typing import Any, Callable, ContextManager, Dict, Generator, List, Literal, NoReturn, Optional, Sequence, Set, Tuple, Type, Union
+from typing import Any, ContextManager, Literal, NoReturn, Final
 from Z0Z_tools.pytestForYourUse import PytestFor_defineConcurrencyLimit, PytestFor_intInnit, PytestFor_oopsieKwargsie
-import pathlib
+import importlib.util
 import pytest
 import random
 import shutil
@@ -19,14 +48,14 @@ import unittest.mock
 import uuid
 
 # SSOT for test data paths and filenames
-pathDataSamples = pathlib.Path("tests/dataSamples")
+pathDataSamples = 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"
+pathTmpRoot: Path = pathDataSamples / "tmp"
 
 # The registrar maintains the register of temp files
-registerOfTemporaryFilesystemObjects: Set[pathlib.Path] = set()
+registerOfTemporaryFilesystemObjects: set[Path] = set()
 
-def registrarRecordsTmpObject(path: pathlib.Path) -> None:
+def registrarRecordsTmpObject(path: Path) -> None:
 	"""The registrar adds a tmp file to the register."""
 	registerOfTemporaryFilesystemObjects.add(path)
 
@@ -51,7 +80,7 @@ def setupTeardownTmpObjects() -> Generator[None, None, None]:
 	registrarDeletesTmpObjects()
 
 @pytest.fixture
-def pathTmpTesting(request: pytest.FixtureRequest) -> pathlib.Path:
+def pathTmpTesting(request: pytest.FixtureRequest) -> 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)
@@ -60,7 +89,7 @@ def pathTmpTesting(request: pytest.FixtureRequest) -> pathlib.Path:
 	return pathTmp
 
 @pytest.fixture
-def pathFilenameTmpTesting(request: pytest.FixtureRequest) -> pathlib.Path:
+def pathFilenameTmpTesting(request: pytest.FixtureRequest) -> Path:
 	try:
 		extension = request.param
 	except AttributeError:
@@ -71,14 +100,14 @@ def pathFilenameTmpTesting(request: pytest.FixtureRequest) -> pathlib.Path:
 	subpath = "Z0Z_" + uuidHex[0:-8]
 	filenameStem = "Z0Z_" + uuidHex[-8:None]
 
-	pathFilenameTmp = pathlib.Path(pathTmpRoot, subpath, filenameStem + extension)
+	pathFilenameTmp = 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]:
+def pathCacheTesting(pathTmpTesting: Path) -> Generator[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
@@ -87,12 +116,12 @@ def pathCacheTesting(pathTmpTesting: pathlib.Path) -> Generator[pathlib.Path, An
 	there_must_be_a_better_way._pathCache = pathCacheOriginal
 
 @pytest.fixture
-def pathFilenameFoldsTotalTesting(pathTmpTesting: pathlib.Path) -> pathlib.Path:
+def pathFilenameFoldsTotalTesting(pathTmpTesting: Path) -> Path:
 	return pathTmpTesting.joinpath("foldsTotalTest.txt")
 
-def makeDictionaryFoldsTotalKnown() -> Dict[Tuple[int,...], int]:
+def makeDictionaryFoldsTotalKnown() -> dict[tuple[int, ...], int]:
 	"""Returns a dictionary mapping dimension tuples to their known folding totals."""
-	dictionaryMapDimensionsToFoldsTotalKnown: Dict[Tuple[int, ...], int] = {}
+	dictionaryMapDimensionsToFoldsTotalKnown: dict[tuple[int, ...], int] = {}
 
 	for settings in settingsOEIS.values():
 		sequence = settings['valuesKnown']
@@ -115,7 +144,7 @@ def setupWarningsAsErrors() -> Generator[None, Any, None]:
 	warnings.resetwarnings()
 
 @pytest.fixture
-def foldsTotalKnown() -> Dict[Tuple[int,...], int]:
+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.
@@ -124,7 +153,7 @@ def foldsTotalKnown() -> Dict[Tuple[int,...], int]:
 	return makeDictionaryFoldsTotalKnown()
 
 @pytest.fixture
-def listDimensionsTestCountFolds(oeisID: str) -> List[int]:
+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:
@@ -139,7 +168,7 @@ def listDimensionsTestCountFolds(oeisID: str) -> List[int]:
 			pass
 
 @pytest.fixture
-def listDimensionsTestFunctionality(oeisID_1random: str) -> List[int]:
+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."""
@@ -155,7 +184,7 @@ def listDimensionsTestFunctionality(oeisID_1random: str) -> List[int]:
 			pass
 
 @pytest.fixture
-def listDimensionsTestParallelization(oeisID: str) -> List[int]:
+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)
@@ -170,7 +199,7 @@ def mockBenchmarkTimer() -> Generator[unittest.mock.MagicMock | unittest.mock.As
 @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]:
+	def make_mock(foldsValue: int, listDimensions: list[int]) -> Callable[..., None]:
 		mock_array = makeDataContainer(2)
 		mock_array[0] = foldsValue
 		mock_array[-1] = getLeavesTotal(listDimensions)
@@ -225,6 +254,35 @@ def useAlgorithmSourceDispatcher(useThisDispatcher: Callable) -> Generator[None,
 	useThisDispatcher(getAlgorithmDispatcher())
 	yield
 
+@pytest.fixture
+def syntheticDispatcherFixture(useThisDispatcher):
+	listCallablesInlineHARDCODED: list[str] = ['countInitialize', 'countParallel', 'countSequential']
+	listCallablesInline = listCallablesInlineHARDCODED
+	callableDispatcher = True
+	algorithmSource = None
+	relativePathWrite = None
+	filenameModuleWrite = 'pytestCount.py'
+	formatFilenameWrite = "pytest_{callableTarget}.py"
+	listSynthesizedModules: list[youOughtaKnow] = makeFlowNumbaOptimized(listCallablesInline, callableDispatcher, algorithmSource, relativePathWrite, filenameModuleWrite, formatFilenameWrite)
+	dispatcherSynthetic = youOughtaKnow('','','')
+	for stuff in listSynthesizedModules:
+		registrarRecordsTmpObject(stuff.pathFilenameForMe)
+		if stuff.callableSynthesized not in listCallablesInline:
+			dispatcherSynthetic: youOughtaKnow = stuff
+
+	dispatcherSpec = importlib.util.spec_from_file_location(dispatcherSynthetic.callableSynthesized, dispatcherSynthetic.pathFilenameForMe)
+	if dispatcherSpec is None:
+		raise ImportError(f"{dispatcherSynthetic.pathFilenameForMe=}")
+	if dispatcherSpec.loader is None:
+		raise ImportError(f"Failed to get loader for module {dispatcherSynthetic.pathFilenameForMe}")
+
+	dispatcherModule = importlib.util.module_from_spec(dispatcherSpec)
+	dispatcherSpec.loader.exec_module(dispatcherModule)
+	callableDispatcherSynthetic = getattr(dispatcherModule, dispatcherSynthetic.callableSynthesized)
+
+	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"
@@ -233,7 +291,7 @@ def uniformTestMessage(expected: Any, actual: Any, functionName: str, *arguments
 
 def standardizedEqualTo(expected: Any, functionTarget: Callable, *arguments: Any) -> None:
 	"""Template for tests expecting an error."""
-	if type(expected) is Type[Exception]:
+	if type(expected) is type[Exception]:
 		messageExpected = expected.__name__
 	else:
 		messageExpected = expected
@@ -246,7 +304,7 @@ def standardizedEqualTo(expected: Any, functionTarget: Callable, *arguments: Any
 
 	assert actual == expected, uniformTestMessage(messageExpected, messageActual, functionTarget.__name__, *arguments)
 
-def standardizedSystemExit(expected: Union[str, int, Sequence[int]], functionTarget: Callable, *arguments: Any) -> None:
+def standardizedSystemExit(expected: str | int | Sequence[int], functionTarget: Callable, *arguments: Any) -> None:
 	"""Template for tests expecting SystemExit.
 
 	Parameters

tests/test_computations.py

@@ -1,79 +1,42 @@
-from pathlib import Path
 from tests.conftest import *
 import importlib.util
 import pytest
 
-def test_algorithmSourceParallel(listDimensionsTestParallelization: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int], useAlgorithmSourceDispatcher: None) -> None:
+def test_algorithmSourceParallel(listDimensionsTestParallelization: list[int], foldsTotalKnown: dict[tuple[int, ...], int], useAlgorithmSourceDispatcher: None) -> None:
 	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
 
-def test_algorithmSourceSequential(listDimensionsTestCountFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int], useAlgorithmSourceDispatcher: None) -> None:
+def test_algorithmSourceSequential(listDimensionsTestCountFolds: list[int], foldsTotalKnown: dict[tuple[int, ...], int], useAlgorithmSourceDispatcher: None) -> None:
 	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestCountFolds)], countFolds, listDimensionsTestCountFolds)
 
 def test_aOFn_calculate_value(oeisID: str) -> None:
 	for n in settingsOEIS[oeisID]['valuesTestValidation']:
 		standardizedEqualTo(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
 
-# Python doesn't want me to test this
-# @pytest.mark.parametrize('pathFilenameTmpTesting', ['.py'], indirect=True)
-# def test_writeJobNumba(listDimensionsTestCountFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int], pathFilenameTmpTesting: Path) -> None:
-# 	from mapFolding.syntheticModules import numba_countSequential
-# 	algorithmSourceHARDCODED: ModuleType = numba_countSequential
-# 	algorithmSource = algorithmSourceHARDCODED
-# 	pathFilenameModule = writeJobNumba(listDimensionsTestCountFolds, algorithmSource, pathFilenameWriteJob=pathFilenameTmpTesting.absolute())
-
-# 	Don_Lapre_Road_to_Self_Improvement = importlib.util.spec_from_file_location("__main__", pathFilenameModule)
-# 	if Don_Lapre_Road_to_Self_Improvement is None:
-# 		raise ImportError(f"Failed to create module specification from {pathFilenameModule}")
-# 	if Don_Lapre_Road_to_Self_Improvement.loader is None:
-# 		raise ImportError(f"Failed to get loader for module {pathFilenameModule}")
-# 	module = importlib.util.module_from_spec(Don_Lapre_Road_to_Self_Improvement)
-
-# 	module.__name__ = "__main__"
-# 	Don_Lapre_Road_to_Self_Improvement.loader.exec_module(module)
-
-# 	pathFilenameFoldsTotal = getPathFilenameFoldsTotal(listDimensionsTestCountFolds)
-# 	standardizedEqualTo(str(foldsTotalKnown[tuple(listDimensionsTestCountFolds)]), pathFilenameFoldsTotal.read_text().strip)
-
-# def test_makeFlowNumbaOptimized(pathTmpTesting: Path, useThisDispatcher):
-# def test_makeFlowNumbaOptimized(useThisDispatcher):
-# 	"""To get this to work:
-# 	walk_up=True doesn't work on 3.10, so that has to go
-# 	the _logical_ import must be in the logical path of the package
-# 	fuck python
-# 	"""
-# 	listCallablesInlineHARDCODED: List[str] = ['countInitialize', 'countParallel', 'countSequential']
-# 	listCallablesInline = listCallablesInlineHARDCODED
-# 	callableDispatcher = True
-# 	algorithmSource = None
-# 	relativePathWrite = None
-# 	# relativePathWrite = pathTmpTesting.absolute().relative_to(getPathPackage(), walk_up=True)
-# 	formatFilenameWrite = "pytest_{callableTarget}"
-# 	listSynthesizedModules: List[youOughtaKnow] = makeFlowNumbaOptimized(listCallablesInline, callableDispatcher, algorithmSource, relativePathWrite, formatFilenameWrite)
-# 	for stuff in listSynthesizedModules:
-# 		registrarRecordsTmpObject(stuff.pathFilenameForMe)
-# 		if stuff.callableSynthesized not in listCallablesInline:
-# 			dispatcherSynthetic: youOughtaKnow = stuff
-# 	if not dispatcherSynthetic: raise FREAKOUT
-# 		# dispatcherSynthetic: youOughtaKnow = next(filter(lambda x: x.callableSynthesized not in listCallablesInline, listSynthesizedModules))
-
-# 	# Import the synthetic dispatcher module to get the callable
-# 	dispatcherSpec = importlib.util.spec_from_file_location(
-# 		dispatcherSynthetic.callableSynthesized,
-# 		dispatcherSynthetic.pathFilenameForMe
-# 	)
-# 	if dispatcherSpec is None:
-# 		raise ImportError(f"Failed to create module specification from {dispatcherSynthetic.pathFilenameForMe}")
-# 	if dispatcherSpec.loader is None:
-# 		raise ImportError(f"Failed to get loader for module {dispatcherSynthetic.pathFilenameForMe}")
-
-# 	dispatcherModule = importlib.util.module_from_spec(dispatcherSpec)
-# 	dispatcherSpec.loader.exec_module(dispatcherModule)
-# 	callableDispatcherSynthetic = getattr(dispatcherModule, dispatcherSynthetic.callableSynthesized)
-
-# 	useThisDispatcher(callableDispatcherSynthetic)
-
-# 	def test_syntheticSequential(listDimensionsTestCountFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]):
-# 		standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestCountFolds)], countFolds, listDimensionsTestCountFolds)
+@pytest.mark.parametrize('pathFilenameTmpTesting', ['.py'], indirect=True)
+def test_writeJobNumba(listDimensionsTestCountFolds: list[int], foldsTotalKnown: dict[tuple[int, ...], int], pathFilenameTmpTesting: Path) -> None:
+	from mapFolding.syntheticModules import numbaCount
+	algorithmSourceHARDCODED: ModuleType = numbaCount
+	algorithmSource = algorithmSourceHARDCODED
+	callableTargetHARDCODED = 'countSequential'
+	callableTarget = callableTargetHARDCODED
+	pathFilenameModule = writeJobNumba(listDimensionsTestCountFolds, algorithmSource, callableTarget, pathFilenameWriteJob=pathFilenameTmpTesting.absolute())
+
+	Don_Lapre_Road_to_Self_Improvement = importlib.util.spec_from_file_location("__main__", pathFilenameModule)
+	if Don_Lapre_Road_to_Self_Improvement is None:
+		raise ImportError(f"Failed to create module specification from {pathFilenameModule}")
+	if Don_Lapre_Road_to_Self_Improvement.loader is None:
+		raise ImportError(f"Failed to get loader for module {pathFilenameModule}")
+	module = importlib.util.module_from_spec(Don_Lapre_Road_to_Self_Improvement)
+
+	module.__name__ = "__main__"
+	Don_Lapre_Road_to_Self_Improvement.loader.exec_module(module)
+
+	pathFilenameFoldsTotal = getPathFilenameFoldsTotal(listDimensionsTestCountFolds)
+	registrarRecordsTmpObject(pathFilenameFoldsTotal)
+	standardizedEqualTo(str(foldsTotalKnown[tuple(listDimensionsTestCountFolds)]), pathFilenameFoldsTotal.read_text().strip)
+
+def test_syntheticParallel(syntheticDispatcherFixture, listDimensionsTestParallelization: list[int], foldsTotalKnown: dict[tuple[int, ...], int]):
+	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
 
-# 	def test_syntheticParallel(listDimensionsTestParallelization: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]):
-# 		standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
+def test_syntheticSequential(syntheticDispatcherFixture, listDimensionsTestCountFolds: list[int], foldsTotalKnown: dict[tuple[int, ...], int]):
+	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestCountFolds)], countFolds, listDimensionsTestCountFolds)

tests/test_oeis.py

@@ -1,10 +1,7 @@
 from contextlib import redirect_stdout
-from datetime import datetime, timedelta
-from mapFolding.oeis import _getFilenameOEISbFile, _getOEISidValues, _parseBFileOEIS, _validateOEISid, _getOEISidInformation
 from tests.conftest import *
 from urllib.error import URLError
 import io
-import os
 import pathlib
 import pytest
 import random
@@ -16,21 +13,20 @@ import urllib.request
 
 @pytest.mark.parametrize("badID", ["A999999", "  A999999  ", "A999999extra"])
 def test__validateOEISid_invalid_id(badID: str) -> None:
-	standardizedEqualTo(KeyError, _validateOEISid, badID)
+	standardizedEqualTo(KeyError, validateOEISid, badID)
 
 def test__validateOEISid_partially_valid(oeisID_1random: str) -> None:
-	standardizedEqualTo(KeyError, _validateOEISid, f"{oeisID_1random}extra")
+	standardizedEqualTo(KeyError, validateOEISid, f"{oeisID_1random}extra")
 
 def test__validateOEISid_valid_id(oeisID: str) -> None:
-	standardizedEqualTo(oeisID, _validateOEISid, oeisID)
+	standardizedEqualTo(oeisID, validateOEISid, oeisID)
 
 def test__validateOEISid_valid_id_case_insensitive(oeisID: str) -> None:
-	standardizedEqualTo(oeisID.upper(), _validateOEISid, oeisID.lower())
-	standardizedEqualTo(oeisID.upper(), _validateOEISid, oeisID.upper())
-	standardizedEqualTo(oeisID.upper(), _validateOEISid, oeisID.swapcase())
+	standardizedEqualTo(oeisID.upper(), validateOEISid, oeisID.lower())
+	standardizedEqualTo(oeisID.upper(), validateOEISid, oeisID.upper())
+	standardizedEqualTo(oeisID.upper(), validateOEISid, oeisID.swapcase())
 
 parameters_test_aOFn_invalid_n = [
-	# (2, "ok"), # test the test template
 	(-random.randint(1, 100), "randomNegative"),
 	("foo", "string"),
 	(1.5, "float")
@@ -62,13 +58,13 @@ def test_clearOEIScache(mock_unlink: unittest.mock.MagicMock, mock_exists: unitt
 		mock_exists.assert_called_once()
 		mock_unlink.assert_not_called()
 
-def testNetworkError(monkeypatch: pytest.MonkeyPatch, pathCacheTesting: pathlib.Path) -> None:
+def testNetworkError(monkeypatch: pytest.MonkeyPatch, pathCacheTesting: Path) -> None:
 	"""Test network error handling."""
 	def mockUrlopen(*args: Any, **kwargs: Any) -> NoReturn:
 		raise URLError("Network error")
 
 	monkeypatch.setattr(urllib.request, 'urlopen', mockUrlopen)
-	standardizedEqualTo(URLError, _getOEISidValues, next(iter(settingsOEIS)))
+	standardizedEqualTo(URLError, getOEISidValues, next(iter(settingsOEIS)))
 
 # ===== Command Line Interface Tests =====
 def testHelpText() -> None: