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

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 *
+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 importlib.util
-import pathlib
 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)
@@ -227,14 +256,14 @@ def useAlgorithmSourceDispatcher(useThisDispatcher: Callable) -> Generator[None,
 
 @pytest.fixture
 def syntheticDispatcherFixture(useThisDispatcher):
-	listCallablesInlineHARDCODED: List[str] = ['countInitialize', 'countParallel', 'countSequential']
+	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)
+	listSynthesizedModules: list[youOughtaKnow] = makeFlowNumbaOptimized(listCallablesInline, callableDispatcher, algorithmSource, relativePathWrite, filenameModuleWrite, formatFilenameWrite)
 	dispatcherSynthetic = youOughtaKnow('','','')
 	for stuff in listSynthesizedModules:
 		registrarRecordsTmpObject(stuff.pathFilenameForMe)
@@ -262,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
@@ -275,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,12 +1,11 @@
-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:
@@ -14,7 +13,7 @@ def test_aOFn_calculate_value(oeisID: str) -> None:
 		standardizedEqualTo(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
 
 @pytest.mark.parametrize('pathFilenameTmpTesting', ['.py'], indirect=True)
-def test_writeJobNumba(listDimensionsTestCountFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int], pathFilenameTmpTesting: Path) -> None:
+def test_writeJobNumba(listDimensionsTestCountFolds: list[int], foldsTotalKnown: dict[tuple[int, ...], int], pathFilenameTmpTesting: Path) -> None:
 	from mapFolding.syntheticModules import numbaCount
 	algorithmSourceHARDCODED: ModuleType = numbaCount
 	algorithmSource = algorithmSourceHARDCODED
@@ -36,8 +35,8 @@ def test_writeJobNumba(listDimensionsTestCountFolds: List[int], foldsTotalKnown:
 	registrarRecordsTmpObject(pathFilenameFoldsTotal)
 	standardizedEqualTo(str(foldsTotalKnown[tuple(listDimensionsTestCountFolds)]), pathFilenameFoldsTotal.read_text().strip)
 
-def test_syntheticParallel(syntheticDispatcherFixture, listDimensionsTestParallelization: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]):
+def test_syntheticParallel(syntheticDispatcherFixture, 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]):
+def test_syntheticSequential(syntheticDispatcherFixture, listDimensionsTestCountFolds: list[int], foldsTotalKnown: dict[tuple[int, ...], int]):
 	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestCountFolds)], countFolds, listDimensionsTestCountFolds)

tests/test_oeis.py

@@ -27,7 +27,6 @@ def test__validateOEISid_valid_id_case_insensitive(oeisID: str) -> None:
 	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")
@@ -59,7 +58,7 @@ 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")

tests/test_other.py

@@ -43,7 +43,11 @@ import sys
 	(range(3, 7), [3, 4, 5, 6], [3, 4, 5, 6], [3, 4, 5, 6], 360),  # range sequence type
 	(tuple([3, 5, 7]), [3, 5, 7], [3, 5, 7], [3, 5, 7], 105),  # tuple sequence type
 ])
-def test_listDimensionsAsParameter(listDimensions: None | List[str] | List[int] | List[float] | List[None] | List[bool] | List[List[int]] | List[complex] | range | tuple[int, ...], expected_intInnit: type[ValueError] | List[int] | type[TypeError], expected_parseListDimensions: type[ValueError] | List[int] | type[TypeError], expected_validateListDimensions: type[ValueError] | type[NotImplementedError] | List[int] | type[TypeError], expected_getLeavesTotal: type[ValueError] | int | type[TypeError] | type[OverflowError]) -> None:
+def test_listDimensionsAsParameter(listDimensions: None | list[str] | list[int] | list[float] | list[None] | list[bool] | list[list[int]] | list[complex] | range | tuple[int, ...],
+								expected_intInnit: type[ValueError] | list[int] | type[TypeError],
+								expected_parseListDimensions: type[ValueError] | list[int] | type[TypeError],
+								expected_validateListDimensions: type[ValueError] | type[NotImplementedError] | list[int] | type[TypeError],
+								expected_getLeavesTotal: type[ValueError] | int | type[TypeError] | type[OverflowError]) -> None:
 	"""Test both validateListDimensions and getLeavesTotal with the same inputs."""
 	standardizedEqualTo(expected_intInnit, intInnit, listDimensions)
 	standardizedEqualTo(expected_parseListDimensions, parseDimensions, listDimensions)
@@ -82,14 +86,14 @@ def testOopsieKwargsie(nameOfTest: str, callablePytest: Callable[[], None]) -> N
 def test_setCPUlimit(CPUlimit: None | float | bool | Literal[4] | Literal[-2] | Literal[0] | Literal[1], expectedLimit: Any | int) -> None:
 	standardizedEqualTo(expectedLimit, setCPUlimit, CPUlimit)
 
-def test_makeConnectionGraph_nonNegative(listDimensionsTestFunctionality: List[int]) -> None:
+def test_makeConnectionGraph_nonNegative(listDimensionsTestFunctionality: list[int]) -> None:
 	connectionGraph = makeConnectionGraph(listDimensionsTestFunctionality)
 	assert numpy.all(connectionGraph >= 0), "All values in the connection graph should be non-negative."
 
 @pytest.fixture
-def parameterIterator() -> Callable[[List[int]], Generator[Dict[str, Any], None, None]]:
+def parameterIterator() -> Callable[[list[int]], Generator[dict[str, Any], None, None]]:
 	"""Generate random combinations of parameters for outfitCountFolds testing."""
-	parameterSets: Dict[str, List[Any]] = {
+	parameterSets: dict[str, list[Any]] = {
 		'computationDivisions': [
 			None,
 			'maximum',
@@ -112,7 +116,7 @@ def parameterIterator() -> Callable[[List[int]], Generator[Dict[str, Any], None,
 		]
 	}
 
-	def makeParametersDynamic(listDimensions: List[int]) -> Dict[str, List[Any]]:
+	def makeParametersDynamic(listDimensions: list[int]) -> dict[str, list[Any]]:
 		"""Add context-dependent parameter values."""
 		parametersDynamic = parameterSets.copy()
 		leavesTotal = getLeavesTotal(listDimensions)
@@ -137,7 +141,7 @@ def parameterIterator() -> Callable[[List[int]], Generator[Dict[str, Any], None,
 
 		return parametersDynamic
 
-	def generateCombinations(listDimensions: List[int]) -> Generator[Dict[str, Any], None, None]:
+	def generateCombinations(listDimensions: list[int]) -> Generator[dict[str, Any], None, None]:
 		parametersDynamic = makeParametersDynamic(listDimensions)
 		parameterKeys = list(parametersDynamic.keys())
 		parameterValues = [parametersDynamic[key] for key in parameterKeys]
@@ -152,7 +156,7 @@ def parameterIterator() -> Callable[[List[int]], Generator[Dict[str, Any], None,
 
 	return generateCombinations
 
-def test_saveFoldsTotal_fallback(pathTmpTesting: pathlib.Path) -> None:
+def test_saveFoldsTotal_fallback(pathTmpTesting: Path) -> None:
 	foldsTotal = 123
 	pathFilename = pathTmpTesting / "foldsTotal.txt"
 	with unittest.mock.patch("pathlib.Path.write_text", side_effect=OSError("Simulated write failure")):

tests/test_tasks.py

@@ -4,10 +4,10 @@ import pytest
 # TODO add a test. `C` = number of logical cores available. `n = C + 1`. Ensure that `[2,n]` is computed correctly.
 # Or, probably smarter: limit the number of cores, then run a test with C+1.
 
-def test_countFoldsComputationDivisionsInvalid(listDimensionsTestFunctionality: List[int]) -> None:
+def test_countFoldsComputationDivisionsInvalid(listDimensionsTestFunctionality: list[int]) -> None:
 	standardizedEqualTo(ValueError, countFolds, listDimensionsTestFunctionality, None, {"wrong": "value"})
 
-def test_countFoldsComputationDivisionsMaximum(listDimensionsTestParallelization: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]) -> None:
+def test_countFoldsComputationDivisionsMaximum(listDimensionsTestParallelization: list[int], foldsTotalKnown: dict[tuple[int, ...], int]) -> None:
 	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
 
 @pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_defineConcurrencyLimit())
@@ -15,7 +15,7 @@ def test_defineConcurrencyLimit(nameOfTest: str, callablePytest: Callable[[], No
 	callablePytest()
 
 @pytest.mark.parametrize("CPUlimitParameter", [{"invalid": True}, ["weird"]])
-def test_countFolds_cpuLimitOopsie(listDimensionsTestFunctionality: List[int], CPUlimitParameter: Dict[str, bool] | List[str]) -> None:
+def test_countFolds_cpuLimitOopsie(listDimensionsTestFunctionality: list[int], CPUlimitParameter: dict[str, bool] | list[str]) -> None:
 	standardizedEqualTo(ValueError, countFolds, listDimensionsTestFunctionality, None, 'cpu', CPUlimitParameter)
 
 @pytest.mark.parametrize("computationDivisions, concurrencyLimit, listDimensions, expectedTaskDivisions", [
@@ -25,7 +25,7 @@ def test_countFolds_cpuLimitOopsie(listDimensionsTestFunctionality: List[int], C
 	(["invalid"], 4, [19, 23], ValueError),
 	(20, 4, [3,5], ValueError)
 ])
-def test_getTaskDivisions(computationDivisions: None | List[str] | Literal['maximum'] | Literal['cpu'] | Literal[20], concurrencyLimit: Literal[4], listDimensions: List[int], expectedTaskDivisions: type[ValueError] | Literal[0] | Literal[77] | Literal[4]) -> None:
+def test_getTaskDivisions(computationDivisions: None | list[str] | Literal['maximum'] | Literal['cpu'] | Literal[20], concurrencyLimit: Literal[4], listDimensions: list[int], expectedTaskDivisions: type[ValueError] | Literal[0] | Literal[77] | Literal[4]) -> None:
 	standardizedEqualTo(expectedTaskDivisions, getTaskDivisions, computationDivisions, concurrencyLimit, None, listDimensions)
 
 @pytest.mark.parametrize("expected,parameter", [
@@ -35,6 +35,6 @@ def test_getTaskDivisions(computationDivisions: None | List[str] | Literal['maxi
 	(ValueError, {2}),  # set
 	(ValueError, {"cores": 2}),  # dict
 ])
-def test_setCPUlimitMalformedParameter(expected: type[ValueError] | Literal[2], parameter: List[int] | Tuple[int] | set[int] | Dict[str, int] | Literal['2']) -> None:
+def test_setCPUlimitMalformedParameter(expected: type[ValueError] | Literal[2], parameter: list[int] | tuple[int] | set[int] | dict[str, int] | Literal['2']) -> None:
 	"""Test that invalid CPUlimit types are properly handled."""
 	standardizedEqualTo(expected, setCPUlimit, parameter)

mapFolding-0.4.3.dist-info/RECORD

@@ -1,40 +0,0 @@
-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/test_types.py

@@ -1,5 +0,0 @@
-"""Type checking tests for mapFolding package."""
-
-def test_static_typing() -> None:
-	"""This is a placeholder. pytest-mypy will run type checking automatically."""
-	pass