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

mapFolding/theSSOTdatatypes.py

@@ -0,0 +1,168 @@
+from collections import defaultdict
+from typing import Any, cast, Dict, Final, Optional, Type, TYPE_CHECKING
+import enum
+import sys
+import numba
+import numpy
+
+try:
+	from typing import NotRequired
+except ImportError:
+	from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+	from typing import TypedDict
+else:
+	TypedDict = dict
+
+@enum.verify(enum.CONTINUOUS, enum.UNIQUE) if sys.version_info >= (3, 11) else lambda x: x
+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: Optional[bool] = 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: Optional[bool] = 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: Optional[bool] = False) -> str:
+	return reportDatatypeLimit('elephino', datatype, sourGrapes)
+
+def setDatatypeFoldsTotal(datatype: str, sourGrapes: Optional[bool] = False) -> str:
+	return reportDatatypeLimit('foldsTotal', datatype, sourGrapes)
+
+def setDatatypeLeavesTotal(datatype: str, sourGrapes: Optional[bool] = 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.4.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.4.2
+Version: 0.4.3
 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

mapFolding-0.4.3.dist-info/RECORD

@@ -0,0 +1,40 @@
+mapFolding/__init__.py,sha256=1-iO5PCGKlW81fhMDjSLrsKxuSeV-UMcU1NlKW352FM,1347
+mapFolding/basecamp.py,sha256=MyrkAbJZawW6CPVEJ_7iPfCYjngdFHmicSs8Ylq5S1E,3787
+mapFolding/beDRY.py,sha256=tDLddJzQoGvbcttJro8ML2B59KspMkZwIeZdm4hOy_4,16785
+mapFolding/oeis.py,sha256=8c6q3STjgp-c4Reode9PLLYS3c00wCsJW-yfte7NI60,11103
+mapFolding/theDao.py,sha256=PZgx_0X7QfdIpLpEO5mbdVNFMCRuP8PD-f62xU7C4U0,12618
+mapFolding/theSSOT.py,sha256=RQmSsjmysc9izjGLsVseZ0J0nDzG_rKY7QkrOF-47SU,5794
+mapFolding/theSSOTdatatypes.py,sha256=H0d1vAn59VCRPMhn28PtlBEZnjmQjEKofiefgvpBFsg,5955
+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=eJRZ8ttfaONMq-s3BawswJrHu_m0DUHp4dGpx6uVpuk,16920
+mapFolding/someAssemblyRequired/synthesizeNumbaGeneralized.py,sha256=3FiD6fDGzam6uvgTg7YEsGlLftbBOol2ajvEa4GNTec,16698
+mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=pknX6CeH9iuDTs9tp0gz33T2U5gjO8NMpPnQnnBU2gA,9138
+mapFolding/someAssemblyRequired/synthesizeNumbaModules.py,sha256=V9xpM1r4MQlhXoKLkF2PTg69gid7Ec64pbMc2ZZ2xXo,5590
+mapFolding/syntheticModules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/syntheticModules/numbaCount.py,sha256=VkTHk97gIBRZg7FwX7hCgfunSBK2Gyr4pp3fzHNrLhw,12907
+mapFolding/syntheticModules/numba_doTheNeedful.py,sha256=9syuZEc1KwH3BFp2TmK7-pBuT2N4lVJTiUhqu7ahaKY,1157
+tests/__init__.py,sha256=eg9smg-6VblOr0kisM40CpGnuDtU2JgEEWGDTFVOlW8,57
+tests/conftest.py,sha256=qP-ZCyyqXC4E9W_psMVbHPlXE-8Ue01fBckGqhzlhGQ,11972
+tests/test_computations.py,sha256=WO28l9AmrFY6kbcx9iJr6YNoqLbZ8Lgs7FryH5DG0BI,2856
+tests/test_oeis.py,sha256=C2F6XrI5oRPjc29lykN3e83rIcgl01UwBLB6L-Qz2pE,4733
+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.3.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapFolding-0.4.3.dist-info/METADATA,sha256=52v3PWTTXMbJwXFaUQFAnJilfn29HFiESW83sPFUL1M,7633
+mapFolding-0.4.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.4.3.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.4.3.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapFolding-0.4.3.dist-info/RECORD,,

tests/conftest.py

@@ -6,11 +6,11 @@ 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 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
+import importlib.util
 import pathlib
 import pytest
 import random
@@ -225,6 +225,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"

tests/test_computations.py

@@ -13,67 +13,31 @@ 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,18 +13,18 @@ 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
@@ -68,7 +65,7 @@ def testNetworkError(monkeypatch: pytest.MonkeyPatch, pathCacheTesting: pathlib.
 		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:

mapFolding/syntheticModules/numba_countInitialize.py

@@ -1,52 +0,0 @@
-from mapFolding import indexMy
-from mapFolding import indexTrack
-from numba import jit
-from numba import uint8
-from numpy import dtype
-from numpy import ndarray
-from numpy import integer
-from typing import Tuple
-from typing import Any
-
-@jit((uint8[:, :, ::1], uint8[::1], uint8[::1], uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=False, no_cpython_wrapper=False, nopython=True, parallel=False)
-def countInitialize(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
-    while my[indexMy.leaf1ndex.value]:
-        if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
-            my[indexMy.dimensionsUnconstrained.value] = my[indexMy.dimensionsTotal.value]
-            my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
-            my[indexMy.indexDimension.value] = 0
-            while my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]:
-                if connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]:
-                    my[indexMy.dimensionsUnconstrained.value] -= 1
-                else:
-                    my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
-                    while my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]:
-                        gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.leafConnectee.value]
-                        if track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] == 0:
-                            my[indexMy.gap1ndexCeiling.value] += 1
-                        track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
-                        my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
-                my[indexMy.indexDimension.value] += 1
-            if not my[indexMy.dimensionsUnconstrained.value]:
-                my[indexMy.indexLeaf.value] = 0
-                while my[indexMy.indexLeaf.value] < my[indexMy.leaf1ndex.value]:
-                    gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.indexLeaf.value]
-                    my[indexMy.gap1ndexCeiling.value] += 1
-                    my[indexMy.indexLeaf.value] += 1
-            my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
-            while my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]:
-                gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
-                if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsUnconstrained.value]:
-                    my[indexMy.gap1ndex.value] += 1
-                track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
-                my[indexMy.indexMiniGap.value] += 1
-        if my[indexMy.leaf1ndex.value]:
-            my[indexMy.gap1ndex.value] -= 1
-            track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]] = gapsWhere[my[indexMy.gap1ndex.value]]
-            track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]] = track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]]
-            track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
-            track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
-            track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
-            my[indexMy.leaf1ndex.value] += 1
-        if my[indexMy.gap1ndex.value] > 0:
-            return

mapFolding/syntheticModules/numba_countParallel.py

@@ -1,65 +0,0 @@
-from mapFolding import indexMy
-from mapFolding import indexTrack
-from numba import prange
-from numba import int64
-from numba import jit
-from numba import uint8
-from numpy import dtype
-from numpy import ndarray
-from numpy import integer
-from typing import Tuple
-from typing import Any
-
-@jit((uint8[:, :, ::1], int64[::1], uint8[::1], uint8[::1], uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=True)
-def countParallel(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
-    gapsWherePARALLEL = gapsWhere.copy()
-    myPARALLEL = my.copy()
-    trackPARALLEL = track.copy()
-    taskDivisionsPrange = myPARALLEL[indexMy.taskDivisions.value]
-    for indexSherpa in prange(taskDivisionsPrange):
-        groupsOfFolds: int = 0
-        gapsWhere = gapsWherePARALLEL.copy()
-        my = myPARALLEL.copy()
-        track = trackPARALLEL.copy()
-        my[indexMy.taskIndex.value] = indexSherpa
-        while my[indexMy.leaf1ndex.value]:
-            if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
-                if my[indexMy.leaf1ndex.value] > foldGroups[-1]:
-                    groupsOfFolds += 1
-                else:
-                    my[indexMy.dimensionsUnconstrained.value] = my[indexMy.dimensionsTotal.value]
-                    my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
-                    my[indexMy.indexDimension.value] = 0
-                    while my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]:
-                        if connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]:
-                            my[indexMy.dimensionsUnconstrained.value] -= 1
-                        else:
-                            my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
-                            while my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]:
-                                if my[indexMy.leaf1ndex.value] != my[indexMy.taskDivisions.value] or my[indexMy.leafConnectee.value] % my[indexMy.taskDivisions.value] == my[indexMy.taskIndex.value]:
-                                    gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.leafConnectee.value]
-                                    if track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] == 0:
-                                        my[indexMy.gap1ndexCeiling.value] += 1
-                                    track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
-                                my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
-                        my[indexMy.indexDimension.value] += 1
-                    my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
-                    while my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]:
-                        gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
-                        if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsUnconstrained.value]:
-                            my[indexMy.gap1ndex.value] += 1
-                        track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
-                        my[indexMy.indexMiniGap.value] += 1
-            while my[indexMy.leaf1ndex.value] and my[indexMy.gap1ndex.value] == track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]:
-                my[indexMy.leaf1ndex.value] -= 1
-                track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]
-                track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]
-            if my[indexMy.leaf1ndex.value]:
-                my[indexMy.gap1ndex.value] -= 1
-                track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]] = gapsWhere[my[indexMy.gap1ndex.value]]
-                track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]] = track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]]
-                track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
-                track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
-                track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
-                my[indexMy.leaf1ndex.value] += 1
-        foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds

mapFolding/syntheticModules/numba_countSequential.py

@@ -1,67 +0,0 @@
-from mapFolding import indexMy
-from mapFolding import indexTrack
-from numba import int64
-from numba import jit
-from numba import uint8
-from numpy import dtype
-from numpy import ndarray
-from numpy import integer
-from typing import Tuple
-from typing import Any
-
-@jit((uint8[:, :, ::1], int64[::1], uint8[::1], uint8[::1], uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=False)
-def countSequential(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
-    leafBelow = track[indexTrack.leafBelow.value]
-    gapRangeStart = track[indexTrack.gapRangeStart.value]
-    countDimensionsGapped = track[indexTrack.countDimensionsGapped.value]
-    leafAbove = track[indexTrack.leafAbove.value]
-    leaf1ndex = my[indexMy.leaf1ndex.value]
-    dimensionsUnconstrained = my[indexMy.dimensionsUnconstrained.value]
-    dimensionsTotal = my[indexMy.dimensionsTotal.value]
-    gap1ndexCeiling = my[indexMy.gap1ndexCeiling.value]
-    indexDimension = my[indexMy.indexDimension.value]
-    leafConnectee = my[indexMy.leafConnectee.value]
-    indexMiniGap = my[indexMy.indexMiniGap.value]
-    gap1ndex = my[indexMy.gap1ndex.value]
-    taskIndex = my[indexMy.taskIndex.value]
-    groupsOfFolds: int = 0
-    while leaf1ndex:
-        if leaf1ndex <= 1 or leafBelow[0] == 1:
-            if leaf1ndex > foldGroups[-1]:
-                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:
-                            gapsWhere[gap1ndexCeiling] = leafConnectee
-                            if countDimensionsGapped[leafConnectee] == 0:
-                                gap1ndexCeiling += 1
-                            countDimensionsGapped[leafConnectee] += 1
-                            leafConnectee = connectionGraph[indexDimension, leaf1ndex, leafBelow[leafConnectee]]
-                    indexDimension += 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 and gap1ndex == gapRangeStart[leaf1ndex - 1]:
-            leaf1ndex -= 1
-            leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]
-            leafAbove[leafBelow[leaf1ndex]] = leafAbove[leaf1ndex]
-        if leaf1ndex:
-            gap1ndex -= 1
-            leafAbove[leaf1ndex] = gapsWhere[gap1ndex]
-            leafBelow[leaf1ndex] = leafBelow[leafAbove[leaf1ndex]]
-            leafBelow[leafAbove[leaf1ndex]] = leaf1ndex
-            leafAbove[leafBelow[leaf1ndex]] = leaf1ndex
-            gapRangeStart[leaf1ndex] = gap1ndex
-            leaf1ndex += 1
-    foldGroups[taskIndex] = groupsOfFolds