mapFolding 0.2.1__py3-none-any.whl → 0.2.2__py3-none-any.whl

tests/conftest.py

@@ -3,31 +3,33 @@ Other test modules must not import directly from the package being tested."""
 
 # TODO learn how to run tests and coverage analysis without `env = ["NUMBA_DISABLE_JIT=1"]`
 
-from typing import Any, Callable, Dict, Generator, List, Optional, Sequence, Tuple, Type, Union
+from typing import Any, Callable, Dict, Generator, List, Optional, Sequence, Set, Tuple, Type, Union
 import pathlib
 import pytest
 import random
+import shutil
 import unittest.mock
-
-from mapFolding import clearOEIScache
-from mapFolding import countFolds, pathJobDEFAULT
+import uuid
+from Z0Z_tools.pytest_parseParameters import makeTestSuiteConcurrencyLimit
+from Z0Z_tools.pytest_parseParameters import makeTestSuiteIntInnit
+from Z0Z_tools.pytest_parseParameters import makeTestSuiteOopsieKwargsie
+from mapFolding import countFolds, pathJobDEFAULT, indexMy, indexThe, indexTrack
+from mapFolding import defineConcurrencyLimit, intInnit, oopsieKwargsie
 from mapFolding import getLeavesTotal, parseDimensions, validateListDimensions
-from mapFolding.importPackages import makeTestSuiteConcurrencyLimit, defineConcurrencyLimit
-from mapFolding.importPackages import makeTestSuiteIntInnit, intInnit
-from mapFolding.importPackages import makeTestSuiteOopsieKwargsie, oopsieKwargsie
+from mapFolding import getTaskDivisions, makeConnectionGraph, outfitFoldings, setCPUlimit
+from mapFolding import oeisIDfor_n, getOEISids, clearOEIScache
+from mapFolding.beDRY import makeDataContainer
 from mapFolding.oeis import OEIS_for_n
-from mapFolding.oeis import _formatFilenameCache
+from mapFolding.oeis import _getFilenameOEISbFile
 from mapFolding.oeis import _getOEISidValues
 from mapFolding.oeis import _parseBFileOEIS
 from mapFolding.oeis import _validateOEISid
-from mapFolding.oeis import getOEISids
-from mapFolding.oeis import oeisIDfor_n
 from mapFolding.oeis import oeisIDsImplemented
 from mapFolding.oeis import settingsOEIS
 
 __all__ = [
     'OEIS_for_n',
-    '_formatFilenameCache',
+    '_getFilenameOEISbFile',
     '_getOEISidValues',
     '_parseBFileOEIS',
     '_validateOEISid',
@@ -37,14 +39,20 @@ __all__ = [
     'expectSystemExit',
     'getLeavesTotal',
     'getOEISids',
+    'indexThe',
+    'getTaskDivisions',
     'intInnit',
+    'makeConnectionGraph',
+    'makeDataContainer',
     'makeTestSuiteConcurrencyLimit',
     'makeTestSuiteIntInnit',
     'makeTestSuiteOopsieKwargsie',
     'oeisIDfor_n',
     'oeisIDsImplemented',
     'oopsieKwargsie',
+    'outfitFoldings',
     'parseDimensions',
+    'setCPUlimit',
     'settingsOEIS',
     'standardCacheTest',
     'standardComparison',
@@ -91,6 +99,75 @@ def makeDictionaryFoldsTotalKnown() -> Dict[Tuple[int,...], int]:
 
     return dictionaryMapDimensionsToFoldsTotalKnown
 
+"""
+Section: temporary paths and pathFilenames"""
+
+# SSOT for test data paths
+pathDataSamples = pathlib.Path("tests/dataSamples")
+pathTempRoot = pathDataSamples / "tmp"
+
+# The registrar maintains the register of temp files
+registerOfTempFiles: Set[pathlib.Path] = set()
+
+def addTempFileToRegister(path: pathlib.Path) -> None:
+    """The registrar adds a temp file to the register."""
+    registerOfTempFiles.add(path)
+
+def cleanupTempFileRegister() -> None:
+    """The registrar cleans up temp files in the register."""
+    for pathTemp in sorted(registerOfTempFiles, reverse=True):
+        try:
+            if pathTemp.is_file():
+                pathTemp.unlink(missing_ok=True)
+            elif pathTemp.is_dir():
+                shutil.rmtree(pathTemp, ignore_errors=True)
+        except Exception as ERRORmessage:
+            print(f"Warning: Failed to clean up {pathTemp}: {ERRORmessage}")
+    registerOfTempFiles.clear()
+
+@pytest.fixture(scope="session", autouse=True)
+def setupTeardownTestData() -> Generator[None, None, None]:
+    """Auto-fixture to setup test data directories and cleanup after."""
+    pathDataSamples.mkdir(exist_ok=True)
+    pathTempRoot.mkdir(exist_ok=True)
+    yield
+    cleanupTempFileRegister()
+
+@pytest.fixture
+def pathTempTesting(request: pytest.FixtureRequest) -> pathlib.Path:
+    """Create a unique temp directory for each test function."""
+    # Sanitize test name for filesystem compatibility
+    sanitizedName = request.node.name.replace('[', '_').replace(']', '_').replace('/', '_')
+    uniqueDirectory = f"{sanitizedName}_{uuid.uuid4()}"
+    pathTemp = pathTempRoot / uniqueDirectory
+    pathTemp.mkdir(parents=True, exist_ok=True)
+
+    addTempFileToRegister(pathTemp)
+    return pathTemp
+
+@pytest.fixture
+def pathCacheTesting(pathTempTesting: 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 = pathTempTesting
+    yield pathTempTesting
+    there_must_be_a_better_way._pathCache = pathCacheOriginal
+
+@pytest.fixture
+def pathFilenameBenchmarksTesting(pathTempTesting: pathlib.Path) -> Generator[pathlib.Path, Any, None]:
+    """Temporarily replace the benchmarks directory with a test directory."""
+    from mapFolding.benchmarks import benchmarking
+    pathFilenameOriginal = benchmarking.pathFilenameRecordedBenchmarks
+    pathFilenameTest = pathTempTesting / "benchmarks.npy"
+    benchmarking.pathFilenameRecordedBenchmarks = pathFilenameTest
+    yield pathFilenameTest
+    benchmarking.pathFilenameRecordedBenchmarks = pathFilenameOriginal
+
+@pytest.fixture
+def pathFilenameFoldsTotalTesting(pathTempTesting: pathlib.Path) -> pathlib.Path:
+    return pathTempTesting.joinpath("foldsTotalTest.txt")
+
 """
 Section: Fixtures"""
 
@@ -150,28 +227,15 @@ def oeisID_1random() -> str:
     """Return one random valid OEIS ID."""
     return random.choice(oeisIDsImplemented)
 
-@pytest.fixture
-def pathCacheTesting(tmp_path: 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 = tmp_path
-    yield tmp_path
-    there_must_be_a_better_way._pathCache = pathCacheOriginal
-
-@pytest.fixture
-def pathBenchmarksTesting(tmp_path: pathlib.Path) -> Generator[pathlib.Path, Any, None]:
-    """Temporarily replace the benchmarks directory with a test directory."""
-    from mapFolding.benchmarks import benchmarking
-    pathOriginal = benchmarking.pathFilenameRecordedBenchmarks
-    pathTest = tmp_path / "benchmarks.npy"
-    benchmarking.pathFilenameRecordedBenchmarks = pathTest
-    yield pathTest
-    benchmarking.pathFilenameRecordedBenchmarks = pathOriginal
-
 """
 Section: Standardized test structures"""
 
+def formatTestMessage(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 standardComparison(expected: Any, functionTarget: Callable, *arguments: Any) -> None:
     """Template for tests expecting an error."""
     if type(expected) == Type[Exception]:
@@ -217,12 +281,6 @@ def expectSystemExit(expected: Union[str, int, Sequence[int]], functionTarget: C
         assert exitCode == expected, \
             f"Expected exit code {expected} but got {exitCode}"
 
-def formatTestMessage(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 standardCacheTest(
     expected: Any,
     setupCacheFile: Optional[Callable[[pathlib.Path, str], None]],
@@ -237,7 +295,7 @@ def standardCacheTest(
         oeisID: OEIS ID to test
         pathCache: Temporary cache directory path
     """
-    pathFilenameCache = pathCache / _formatFilenameCache.format(oeisID=oeisID)
+    pathFilenameCache = pathCache / _getFilenameOEISbFile(oeisID)
 
     # Setup cache file if provided
     if setupCacheFile:

tests/test_oeis.py

@@ -1,6 +1,7 @@
-from .conftest import *
+from tests.conftest import *
 from contextlib import redirect_stdout
 from datetime import datetime, timedelta
+from typing import Optional, Tuple, Union
 import io
 import os
 import pathlib
@@ -62,29 +63,27 @@ def test_clearOEIScache(mock_unlink: unittest.mock.MagicMock, mock_exists: unitt
         mock_exists.assert_called_once()
         mock_unlink.assert_not_called()
 
-def testCacheMiss(pathCacheTesting: pathlib.Path, oeisID_1random: str):
-    """Test cache miss scenario - cache file doesn't exist."""
-    # No setup function needed - we want to test missing cache
-    standardCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], None, oeisID_1random, pathCacheTesting)
+@pytest.mark.parametrize("scenarioCache", ["miss", "expired", "invalid"])
+def testCacheScenarios(pathCacheTesting: pathlib.Path, oeisID_1random: str, scenarioCache: str) -> None:
+    """Test cache scenarios: missing file, expired file, and invalid file."""
 
-def testCacheExpired(pathCacheTesting: pathlib.Path, oeisID_1random: str):
-    """Test expired cache scenario."""
-    def setupExpiredCache(pathCache: pathlib.Path, oeisID: str) -> None:
+    def setupCacheExpired(pathCache: pathlib.Path, oeisID: str) -> None:
         pathCache.write_text("# Old cache content")
         oldModificationTime = datetime.now() - timedelta(days=30)
         os.utime(pathCache, times=(oldModificationTime.timestamp(), oldModificationTime.timestamp()))
 
-    standardCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], setupExpiredCache, oeisID_1random, pathCacheTesting)
-
-def testInvalidCache(pathCacheTesting: pathlib.Path, oeisID_1random: str):
-    """Test invalid cache content scenario."""
-    def setupInvalidCache(pathCache: pathlib.Path, oeisID: str) -> None:
+    def setupCacheInvalid(pathCache: pathlib.Path, oeisID: str) -> None:
         pathCache.write_text("Invalid content")
 
-    standardCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], setupInvalidCache, oeisID_1random, pathCacheTesting)
+    if scenarioCache == "miss":
+        standardCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], None, oeisID_1random, pathCacheTesting)
+    elif scenarioCache == "expired":
+        standardCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], setupCacheExpired, oeisID_1random, pathCacheTesting)
+    else:
+        standardCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], setupCacheInvalid, oeisID_1random, pathCacheTesting)
 
 def testInvalidFileContent(pathCacheTesting: pathlib.Path, oeisID_1random: str):
-    pathFilenameCache = pathCacheTesting / _formatFilenameCache.format(oeisID=oeisID_1random)
+    pathFilenameCache = pathCacheTesting / _getFilenameOEISbFile(oeisID=oeisID_1random)
 
     # Write invalid content to cache
     pathFilenameCache.write_text("# A999999\n1 1\n2 2\n")
@@ -100,25 +99,17 @@ def testInvalidFileContent(pathCacheTesting: pathlib.Path, oeisID_1random: str):
     # Verify cache now contains correct sequence ID
     assert f"# {oeisID_1random}" in pathFilenameCache.read_text()
 
-def testNetworkError(monkeypatch: pytest.MonkeyPatch, pathCacheTesting: pathlib.Path):
-    def mockUrlopen(*args, **kwargs):
-        raise urllib.error.URLError("Network error")
-
-    monkeypatch.setattr(urllib.request, 'urlopen', mockUrlopen)
-    with pytest.raises(urllib.error.URLError):
-        _getOEISidValues(next(iter(settingsOEIS)))
-
 def testParseContentErrors():
     """Test invalid content parsing."""
     standardComparison(ValueError, _parseBFileOEIS, "Invalid content\n1 2\n", 'A001415')
 
 def testExtraComments(pathCacheTesting: pathlib.Path, oeisID_1random: str):
-    pathFilenameCache = pathCacheTesting / _formatFilenameCache.format(oeisID=oeisID_1random)
+    pathFilenameCache = pathCacheTesting / _getFilenameOEISbFile(oeisID=oeisID_1random)
 
     # Write content with extra comment lines
     contentWithExtraComments = f"""# {oeisID_1random}
-# Extra comment line 1
-# Extra comment line 2
+# Normal place for comment line 1
+# Abnormal comment line
 1 2
 2 4
 3 6
@@ -133,6 +124,14 @@ def testExtraComments(pathCacheTesting: pathlib.Path, oeisID_1random: str):
     standardComparison(8, lambda d: d[4], OEISsequence)  # Value after mid-sequence comment
     standardComparison(10, lambda d: d[5], OEISsequence)  # Last value
 
+def testNetworkError(monkeypatch: pytest.MonkeyPatch, pathCacheTesting: pathlib.Path):
+    """Test network error handling."""
+    def mockUrlopen(*args, **kwargs):
+        raise urllib.error.URLError("Network error")
+
+    monkeypatch.setattr(urllib.request, 'urlopen', mockUrlopen)
+    standardComparison(urllib.error.URLError, _getOEISidValues, next(iter(settingsOEIS)))
+
 # ===== Command Line Interface Tests =====
 def testHelpText():
     """Test that help text is complete and examples are valid."""

tests/test_other.py

@@ -1,7 +1,13 @@
+from pathlib import Path
+from typing import List
 from .conftest import *
 import pytest
 import sys
-# TODO test `outfitFoldings`, especially that `listDimensions` is sorted.
+import unittest.mock
+import numpy
+import numba
+
+# TODO test `outfitFoldings`; no negative values in arrays; compare datatypes to the typeddict; commpare the connection graph to making a graPH
 
 @pytest.mark.parametrize("listDimensions,expected_intInnit,expected_parseListDimensions,expected_validateListDimensions,expected_getLeavesTotal", [
     (None, ValueError, ValueError, ValueError, ValueError),  # None instead of list
@@ -53,7 +59,19 @@ def test_getLeavesTotal_edge_cases() -> None:
     standardComparison(6, getLeavesTotal, listOriginal)
     standardComparison([2, 3], lambda x: x, listOriginal)  # Check that the list wasn't modified
 
-# ===== Parse Integers Tests =====
+def test_countFolds_writeFoldsTotal_file(listDimensionsTestFunctionality: List[int], pathFilenameFoldsTotalTesting: Path) -> None:
+    with unittest.mock.patch("mapFolding.babbage._countFolds", return_value=12345):
+        standardComparison(12345, countFolds, listDimensionsTestFunctionality, pathFilenameFoldsTotalTesting)
+    standardComparison("12345", lambda: pathFilenameFoldsTotalTesting.read_text())
+
+def test_countFolds_writeFoldsTotal_directory(listDimensionsTestFunctionality: List[int], pathTempTesting: Path) -> None:
+    with unittest.mock.patch("mapFolding.babbage._countFolds", return_value=67890):
+        returned = countFolds(listDimensionsTestFunctionality, writeFoldsTotal=pathTempTesting)
+    standardComparison(67890, lambda: returned)
+    # Construct expected filename from sorted dimensions
+    expectedName = str(sorted(listDimensionsTestFunctionality)).replace(' ', '') + '.foldsTotal'
+    standardComparison("67890", lambda: (pathTempTesting / expectedName).read_text())
+
 def test_intInnit() -> None:
     """Test integer parsing using the test suite generator."""
     for testName, testFunction in makeTestSuiteIntInnit(intInnit).items():
@@ -64,5 +82,24 @@ def test_oopsieKwargsie() -> None:
     for testName, testFunction in makeTestSuiteOopsieKwargsie(oopsieKwargsie).items():
         testFunction()
 
-def test_parseListDimensions_noDimensions() -> None:
-    standardComparison(ValueError, parseDimensions, [])
+# TODO mock CPU counts?
+# @pytest.mark.parametrize("CPUlimit, expectedLimit", [
+#     (None, numba.config.NUMBA_DEFAULT_NUM_THREADS),
+#     (False, numba.config.NUMBA_DEFAULT_NUM_THREADS),
+#     (True, 1),
+#     (4, 4),
+#     (0.5, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS // 2)),
+#     (-0.5, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS // 2)),
+#     (-2, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS - 2)),
+# ])
+# def test_setCPUlimit(CPUlimit, expectedLimit) -> None:
+#     standardComparison(expectedLimit, setCPUlimit, CPUlimit)
+
+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.mark.parametrize("datatype", [numpy.int16, numpy.uint64])
+def test_makeConnectionGraph_datatype(listDimensionsTestFunctionality: List[int], datatype) -> None:
+    connectionGraph = makeConnectionGraph(listDimensionsTestFunctionality, datatype=datatype)
+    assert connectionGraph.dtype == datatype, f"Expected datatype {datatype}, but got {connectionGraph.dtype}."

tests/test_tasks.py

@@ -3,6 +3,7 @@ import pytest
 from typing import List, Dict, Tuple
 
 # 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_countFolds_computationDivisions(listDimensionsTest_countFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]) -> None:
     standardComparison(foldsTotalKnown[tuple(listDimensionsTest_countFolds)], countFolds, listDimensionsTest_countFolds, None, 'maximum')
@@ -14,8 +15,17 @@ def test_defineConcurrencyLimit() -> None:
 
 @pytest.mark.parametrize("CPUlimitParameter", [{"invalid": True}, ["weird"]])
 def test_countFolds_cpuLimitOopsie(listDimensionsTestFunctionality: List[int], CPUlimitParameter: Dict[str, bool] | List[str]) -> None:
-    # This forces CPUlimit = oopsieKwargsie(cpuLimitValue).
     standardComparison(ValueError, countFolds, listDimensionsTestFunctionality, None, 'cpu', CPUlimitParameter)
 
 def test_countFolds_invalid_computationDivisions(listDimensionsTestFunctionality: List[int]) -> None:
     standardComparison(ValueError, countFolds, listDimensionsTestFunctionality, None, {"wrong": "value"})
+
+@pytest.mark.parametrize("computationDivisions, concurrencyLimit, listDimensions, expectedTaskDivisions", [
+    (None, 4, [9, 11], 0),
+    ("maximum", 4, [7, 11], 77),
+    ("cpu", 4, [3, 7], 4),
+    (["invalid"], 4, [19, 23], ValueError),
+    (20, 4, [3,5], ValueError)
+])
+def test_getTaskDivisions(computationDivisions, concurrencyLimit, listDimensions, expectedTaskDivisions) -> None:
+    standardComparison(expectedTaskDivisions, getTaskDivisions, computationDivisions, concurrencyLimit, None, listDimensions)

mapFolding/importPackages.py

@@ -1,5 +0,0 @@
-"""Experiment"""
-from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
-from Z0Z_tools.pytest_parseParameters import makeTestSuiteConcurrencyLimit
-from Z0Z_tools.pytest_parseParameters import makeTestSuiteIntInnit
-from Z0Z_tools.pytest_parseParameters import makeTestSuiteOopsieKwargsie

mapFolding-0.2.1.dist-info/RECORD

@@ -1,28 +0,0 @@
-mapFolding/__init__.py,sha256=3kQQWyOBriVg9wO5btGE1Cq3lNqJz6CudrkOxVWcsy8,368
-mapFolding/babbage.py,sha256=3D1qcntoiJm2tqgbiCAMc7GpGA0SZTdGORNEnensyxk,1882
-mapFolding/beDRY.py,sha256=QACsmdskZplzMpYGUu7DSTSCE7x5JFApEyUqvUh0H0c,12613
-mapFolding/importPackages.py,sha256=Pno5VXaNiyJKG2Jtj4sB_h6EG50IJ7tQKyivVoKFMxo,303
-mapFolding/lovelace.py,sha256=qcyGpVEPP3n0r-RNrSUgPRP3yZJfBEfmok7jYMm1OI0,11473
-mapFolding/oeis.py,sha256=c8oCAcWgLvwC-bBZzGty8yth1vWtT8lWcKQeCiNGYgw,12078
-mapFolding/startHere.py,sha256=Z73A2bm35XygF6bpz710S8G2tVRdU_5-nO-nDgTaDhM,5068
-mapFolding/theSSOT.py,sha256=-t23-gPLPNWWBEeSi1mKkNCeeQA4y1AA_oPKC7tZwe4,1970
-mapFolding/JAX/lunnanJAX.py,sha256=xMZloN47q-MVfjdYOM1hi9qR4OnLq7qALmGLMraevQs,14819
-mapFolding/JAX/taskJAX.py,sha256=yJNeH0rL6EhJ6ppnATHF0Zf81CDMC10bnPnimVxE1hc,20037
-mapFolding/benchmarks/benchmarking.py,sha256=kv85F6V9pGhZvTOImArOuxyg5rywA_T6JLH_qFXM8BM,3018
-mapFolding/benchmarks/test_benchmarks.py,sha256=c4ANeR3jgqpKXFoxDeZkmAHxSuenMwsjmrhKJ1_XPqY,3659
-mapFolding/reference/hunterNumba.py,sha256=jV0dBjhLcnJjUHWRxLV_xvPIUP_GRLRKVeDhOtM9Wp4,7475
-mapFolding/reference/irvineJavaPort.py,sha256=Sj-63Z-OsGuDoEBXuxyjRrNmmyl0d7Yz_XuY7I47Oyg,4250
-mapFolding/reference/lunnan.py,sha256=SwjpOr1ROg-yZaZuiL7XjXhuvBxu_K4gQoPAWKUjJk4,5037
-mapFolding/reference/lunnanNumpy.py,sha256=bDQsBZUQcqJ9bTdnMF7HgtPcgpIodctujkm_lpq9NZ4,4653
-mapFolding/reference/lunnanWhile.py,sha256=p8_zLdMc6ujTYIu_yn-hbzOuLTQHvo0ENciIDmKayDU,4067
-mapFolding/reference/rotatedEntryPoint.py,sha256=6WVvEcGwDgRPa7dDs7ODAHUJjHDZDIDN6CXH8fFVFmA,12105
-tests/__init__.py,sha256=PGYVr7r23gATgcvZ3Sfph9D_g1MVvhgzMNWXBs_9tmY,52
-tests/conftest.py,sha256=ur6l5nDnWju7zOEMXqoNGYHY-Hf9GApOm4VT9pXtMtY,10594
-tests/test_oeis.py,sha256=h-NhWRoarl3v6qoB0RpnaUPuMGrQpWyfmsL0FXsGauU,7972
-tests/test_other.py,sha256=3Qc6fA39q5u_U0JhFUB9mdBd5_XcVC7IP9DwlNuG9p8,4716
-tests/test_tasks.py,sha256=Hn4N8OVVfDeNjL7ad5ELKKDgdOn8sDBj6IebPGpLIlE,1254
-mapFolding-0.2.1.dist-info/METADATA,sha256=r7QVig9M5_DReHsPG_wyyRNJe0UkggfUotMf8tfoF7I,5914
-mapFolding-0.2.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.2.1.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.2.1.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapFolding-0.2.1.dist-info/RECORD,,