mapFolding 0.3.9__py3-none-any.whl → 0.3.10__py3-none-any.whl

tests/test_oeis.py

@@ -1,8 +1,9 @@
 from contextlib import redirect_stdout
 from datetime import datetime, timedelta
-from mapFolding.oeis import _getFilenameOEISbFile, _getOEISidValues, _parseBFileOEIS, _validateOEISid
+from mapFolding.oeis import _getFilenameOEISbFile, _getOEISidValues, _parseBFileOEIS, _validateOEISid, _getOEISidInformation
 from tests.conftest import *
-from typing import Optional, NoReturn, Tuple, Union
+from typing import NoReturn
+from urllib.error import URLError
 import io
 import os
 import pathlib
@@ -12,7 +13,6 @@ import re as regex
 import unittest
 import unittest.mock
 import urllib
-from urllib.error import URLError
 import urllib.request
 
 def test_algorithmSourceSequential(oeisID: str, useAlgorithmDirectly: None) -> None:
@@ -63,73 +63,14 @@ def test_clearOEIScache(mock_unlink: unittest.mock.MagicMock, mock_exists: unitt
     clearOEIScache()
 
     if cacheExists:
-        assert mock_unlink.call_count == len(settingsOEIS)
-        mock_unlink.assert_has_calls([unittest.mock.call(missing_ok=True)] * len(settingsOEIS))
+        # Each OEIS ID has two cache files
+        expected_calls = len(settingsOEIS) * 2
+        assert mock_unlink.call_count == expected_calls
+        mock_unlink.assert_has_calls([unittest.mock.call(missing_ok=True)] * expected_calls)
     else:
         mock_exists.assert_called_once()
         mock_unlink.assert_not_called()
 
-@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 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()))
-
-    def setupCacheInvalid(pathCache: pathlib.Path, oeisID: str) -> None:
-        pathCache.write_text("Invalid content")
-
-    if scenarioCache == "miss":
-        prototypeCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], None, oeisID_1random, pathCacheTesting)
-    elif scenarioCache == "expired":
-        prototypeCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], setupCacheExpired, oeisID_1random, pathCacheTesting)
-    else:
-        prototypeCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], setupCacheInvalid, oeisID_1random, pathCacheTesting)
-
-def testInvalidFileContent(pathCacheTesting: pathlib.Path, oeisID_1random: str) -> None:
-    pathFilenameCache = pathCacheTesting / _getFilenameOEISbFile(oeisID=oeisID_1random)
-
-    # Write invalid content to cache
-    pathFilenameCache.write_text("# A999999\n1 1\n2 2\n")
-    modificationTimeOriginal = pathFilenameCache.stat().st_mtime
-
-    # Function should detect invalid content, fetch fresh data, and update cache
-    OEISsequence = _getOEISidValues(oeisID_1random)
-
-    # Verify the function succeeded
-    assert OEISsequence is not None
-    # Verify cache was updated (modification time changed)
-    assert pathFilenameCache.stat().st_mtime > modificationTimeOriginal
-    # Verify cache now contains correct sequence ID
-    assert f"# {oeisID_1random}" in pathFilenameCache.read_text()
-
-def testParseContentErrors() -> None:
-    """Test invalid content parsing."""
-    standardizedEqualTo(ValueError, _parseBFileOEIS, "Invalid content\n1 2\n", 'A001415')
-
-def testExtraComments(pathCacheTesting: pathlib.Path, oeisID_1random: str) -> None:
-    pathFilenameCache = pathCacheTesting / _getFilenameOEISbFile(oeisID=oeisID_1random)
-
-    # Write content with extra comment lines
-    contentWithExtraComments = f"""# {oeisID_1random}
-# Normal place for comment line 1
-# Abnormal comment line
-1 2
-2 4
-3 6
-# Another comment in the middle
-4 8
-5 10"""
-    pathFilenameCache.write_text(contentWithExtraComments)
-
-    OEISsequence = _getOEISidValues(oeisID_1random)
-    # Verify sequence values are correct despite extra comments
-    standardizedEqualTo(2, lambda d: d[1], OEISsequence)  # First value
-    standardizedEqualTo(8, lambda d: d[4], OEISsequence)  # Value after mid-sequence comment
-    standardizedEqualTo(10, lambda d: d[5], OEISsequence)  # Last value
-
 def testNetworkError(monkeypatch: pytest.MonkeyPatch, pathCacheTesting: pathlib.Path) -> None:
     """Test network error handling."""
     def mockUrlopen(*args: Any, **kwargs: Any) -> NoReturn:

tests/test_other.py

@@ -61,35 +61,36 @@ def test_getLeavesTotal_edge_cases() -> None:
     standardizedEqualTo(6, getLeavesTotal, listOriginal)
     standardizedEqualTo([2, 3], lambda x: x, listOriginal)  # Check that the list wasn't modified
 
-@pytest.mark.parametrize("foldsValue,writeFoldsTarget", [
-    (756839, "foldsTotalTest.txt"),  # Direct file
-    (2640919, "foldsTotalTest.txt"), # Direct file
-    (7715177, None),                  # Directory, will use default filename
-])
-def test_countFolds_writeFoldsTotal(
-    listDimensionsTestFunctionality: List[int],
-    pathTempTesting: pathlib.Path,
-    mockFoldingFunction: Callable[..., Callable[..., None]],
-    mockDispatcher: Callable[[Callable[..., None]], Any],
-    foldsValue: int,
-    writeFoldsTarget: Optional[str]
-) -> None:
-    """Test writing folds total to either a file or directory."""
-    # For directory case, use the directory path directly
-    if writeFoldsTarget is None:
-        pathWriteTarget = pathTempTesting
-        filenameFoldsTotalExpected = getFilenameFoldsTotal(listDimensionsTestFunctionality)
-    else:
-        pathWriteTarget = pathTempTesting / writeFoldsTarget
-        filenameFoldsTotalExpected = writeFoldsTarget
-
-    foldsTotalExpected = foldsValue * getLeavesTotal(listDimensionsTestFunctionality)
-    mock_countFolds = mockFoldingFunction(foldsValue, listDimensionsTestFunctionality)
-
-    with mockDispatcher(mock_countFolds):
-        returned = countFolds(listDimensionsTestFunctionality, pathLikeWriteFoldsTotal=pathWriteTarget)
-
-    standardizedEqualTo(str(foldsTotalExpected), lambda: (pathTempTesting / filenameFoldsTotalExpected).read_text())
+# TODO fix this mock
+# @pytest.mark.parametrize("foldsValue,writeFoldsTarget", [
+#     (756839, "foldsTotalTest.txt"),  # Direct file
+#     (2640919, "foldsTotalTest.txt"), # Direct file
+#     (7715177, None),                  # Directory, will use default filename
+# ])
+# def test_countFolds_writeFoldsTotal(
+#     listDimensionsTestFunctionality: List[int],
+#     pathTempTesting: pathlib.Path,
+#     mockFoldingFunction: Callable[..., Callable[..., None]],
+#     mockDispatcher: Callable[[Callable[..., None]], Any],
+#     foldsValue: int,
+#     writeFoldsTarget: Optional[str]
+# ) -> None:
+#     """Test writing folds total to either a file or directory."""
+#     # For directory case, use the directory path directly
+#     if writeFoldsTarget is None:
+#         pathWriteTarget = pathTempTesting
+#         filenameFoldsTotalExpected = getFilenameFoldsTotal(listDimensionsTestFunctionality)
+#     else:
+#         pathWriteTarget = pathTempTesting / writeFoldsTarget
+#         filenameFoldsTotalExpected = writeFoldsTarget
+
+#     foldsTotalExpected = foldsValue * getLeavesTotal(listDimensionsTestFunctionality)
+#     mock_countFolds = mockFoldingFunction(foldsValue, listDimensionsTestFunctionality)
+
+#     with mockDispatcher(mock_countFolds):
+#         returned = countFolds(listDimensionsTestFunctionality, pathLikeWriteFoldsTotal=pathWriteTarget)
+
+#     standardizedEqualTo(str(foldsTotalExpected), lambda: (pathTempTesting / filenameFoldsTotalExpected).read_text())
 
 @pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_intInnit())
 def testIntInnit(nameOfTest: str, callablePytest: Callable[[], None]) -> None:

mapFolding/someAssemblyRequired/synthesizeModuleJobNumba.py

@@ -1,212 +0,0 @@
-from mapFolding import getPathFilenameFoldsTotal, indexMy, indexTrack
-from mapFolding import setDatatypeElephino, setDatatypeFoldsTotal, setDatatypeLeavesTotal, setDatatypeModule, hackSSOTdatatype
-from someAssemblyRequired import makeStateJob
-from typing import Optional
-import importlib
-import importlib.util
-import inspect
-import more_itertools
-import numpy
-import pathlib
-import python_minifier
-
-identifierCallableLaunch = "goGoGadgetAbsurdity"
-
-def makeStrRLEcompacted(arrayTarget: numpy.ndarray, identifierName: str) -> str:
-    """Converts a NumPy array into a compressed string representation using run-length encoding (RLE).
-
-    This function takes a NumPy array and converts it into an optimized string representation by:
-    1. Compressing consecutive sequences of numbers into range objects
-    2. Minimizing repeated zeros using array multiplication syntax
-    3. Converting the result into a valid Python array initialization statement
-
-    Parameters:
-        arrayTarget (numpy.ndarray): The input NumPy array to be converted
-        identifierName (str): The variable name to use in the output string
-
-    Returns:
-        str: A string containing Python code that recreates the input array in compressed form.
-            Format: "{identifierName} = numpy.array({compressed_data}, dtype=numpy.{dtype})"
-
-    Example:
-        >>> arr = numpy.array([[0,0,0,1,2,3,4,0,0]])
-        >>> print(makeStrRLEcompacted(arr, "myArray"))
-        "myArray = numpy.array([[0]*3,*range(1,5),[0]*2], dtype=numpy.int64)"
-
-    Notes:
-        - Sequences of 4 or fewer numbers are kept as individual values
-        - Sequences longer than 4 numbers are converted to range objects
-        - Consecutive zeros are compressed using multiplication syntax
-        - The function preserves the original array's dtype
-    """
-
-    def compressRangesNDArrayNoFlatten(arraySlice):
-        if isinstance(arraySlice, numpy.ndarray) and arraySlice.ndim > 1:
-            return [compressRangesNDArrayNoFlatten(arraySlice[index]) for index in range(arraySlice.shape[0])]
-        elif isinstance(arraySlice, numpy.ndarray) and arraySlice.ndim == 1:
-            listWithRanges = []
-            for group in more_itertools.consecutive_groups(arraySlice.tolist()):
-                ImaSerious = list(group)
-                if len(ImaSerious) <= 4:
-                    listWithRanges += ImaSerious
-                else:
-                    ImaRange = [range(ImaSerious[0], ImaSerious[-1] + 1)]
-                    listWithRanges += ImaRange
-            return listWithRanges
-        return arraySlice
-
-    arrayAsNestedLists = compressRangesNDArrayNoFlatten(arrayTarget)
-
-    stringMinimized = python_minifier.minify(str(arrayAsNestedLists))
-    commaZeroMaximum = arrayTarget.shape[-1] - 1
-    stringMinimized = stringMinimized.replace('[0' + ',0'*commaZeroMaximum + ']', '[0]*'+str(commaZeroMaximum+1))
-    for countZeros in range(commaZeroMaximum, 2, -1):
-        stringMinimized = stringMinimized.replace(',0'*countZeros + ']', ']+[0]*'+str(countZeros))
-
-    stringMinimized = stringMinimized.replace('range', '*range')
-
-    return f"{identifierName} = numpy.array({stringMinimized}, dtype=numpy.{arrayTarget.dtype})"
-
-def writeModuleWithNumba(listDimensions) -> pathlib.Path:
-    """
-    Writes a Numba-optimized Python module for map folding calculations.
-
-    This function takes map dimensions and generates a specialized Python module with Numba
-    optimizations. It processes a sequential counting algorithm, adds Numba decorators and
-    necessary data structures, and writes the resulting code to a file.
-
-    Parameters:
-        listDimensions: List of integers representing the dimensions of the map to be folded.
-
-    Returns:
-        pathlib.Path: Path to the generated Python module file.
-
-    The generated module includes:
-    - Numba JIT compilation decorators for performance optimization
-    - Required numpy and numba imports
-    - Dynamic and static data structures needed for folding calculations
-    - Processed algorithm from the original sequential counter
-    - Launch code for standalone execution
-    - Code to write the final fold count to a file
-    The function handles:
-    - Translation of original code to Numba-compatible syntax
-    - Insertion of pre-calculated values from the state job
-    - Management of variable declarations and assignments
-    - Setup of proper data types for Numba optimization
-    - Organization of the output file structure
-
-    Note:
-        The generated module requires Numba and numpy to be installed.
-        The output file will be placed in the same directory as the folds total file,
-        with a .py extension.
-    """
-    stateJob = makeStateJob(listDimensions, writeJob=False)
-    pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateJob['mapShape'])
-
-    from syntheticModules import countSequential
-    algorithmSource = countSequential
-    codeSource = inspect.getsource(algorithmSource)
-
-    lineNumba = f"@numba.jit(numba.types.{hackSSOTdatatype('datatypeFoldsTotal')}(), cache=True, nopython=True, fastmath=True, forceinline=True, inline='always', looplift=False, _nrt=True, error_model='numpy', parallel=False, boundscheck=False, no_cfunc_wrapper=False, no_cpython_wrapper=False)"
-
-    linesImport = "\n".join([
-                        "import numpy"
-                        , "import numba"
-                        ])
-
-    ImaIndent = '    '
-    linesDataDynamic = """"""
-    linesDataDynamic = "\n".join([linesDataDynamic
-            , ImaIndent + makeStrRLEcompacted(stateJob['gapsWhere'], 'gapsWhere')
-            ])
-
-    linesDataStatic = """"""
-    linesDataStatic = "\n".join([linesDataStatic
-            , ImaIndent + makeStrRLEcompacted(stateJob['connectionGraph'], 'connectionGraph')
-            ])
-
-    my = stateJob['my']
-    track = stateJob['track']
-    linesAlgorithm = """"""
-    for lineSource in codeSource.splitlines():
-        if lineSource.startswith(('#', 'import', 'from', '@numba.jit')):
-            continue
-        elif not lineSource:
-            continue
-        elif lineSource.startswith('def '):
-            lineSource = "\n".join([lineNumba
-                                , f"def {identifierCallableLaunch}():"
-                                , linesDataDynamic
-                                , linesDataStatic
-                                ])
-        elif 'taskIndex' in lineSource:
-            continue
-        elif 'my[indexMy.' in lineSource:
-            if 'dimensionsTotal' in lineSource:
-                continue
-            # Statements are in the form: leaf1ndex = my[indexMy.leaf1ndex.value]
-            identifier, statement = lineSource.split('=')
-            lineSource = ImaIndent + identifier.strip() + f"=numba.types.{hackSSOTdatatype(identifier.strip())}({str(eval(statement.strip()))})"
-        elif ': int =' in lineSource or ':int=' in lineSource:
-            if 'dimensionsTotal' in lineSource:
-                continue
-            # Statements are in the form: groupsOfFolds: int = 0
-            assignment, statement = lineSource.split('=')
-            identifier = assignment.split(':')[0].strip()
-            lineSource = ImaIndent + identifier.strip() + f"=numba.types.{hackSSOTdatatype(identifier.strip())}({str(eval(statement.strip()))})"
-        elif 'track[indexTrack.' in lineSource:
-            # Statements are in the form: leafAbove = track[indexTrack.leafAbove.value]
-            identifier, statement = lineSource.split('=')
-            lineSource = ImaIndent + makeStrRLEcompacted(eval(statement.strip()), identifier.strip())
-        elif 'foldGroups[-1]' in lineSource:
-            lineSource = lineSource.replace('foldGroups[-1]', str(stateJob['foldGroups'][-1]))
-        elif 'dimensionsTotal' in lineSource:
-            lineSource = lineSource.replace('dimensionsTotal', str(stateJob['my'][indexMy.dimensionsTotal]))
-
-        linesAlgorithm = "\n".join([linesAlgorithm
-                            , lineSource
-                            ])
-
-    linesLaunch = """"""
-    linesLaunch = linesLaunch + f"""
-if __name__ == '__main__':
-    # import time
-    # timeStart = time.perf_counter()
-    {identifierCallableLaunch}()
-    # print(time.perf_counter() - timeStart)
-"""
-
-    linesWriteFoldsTotal = """"""
-    linesWriteFoldsTotal = "\n".join([linesWriteFoldsTotal
-                                    , f"    groupsOfFolds *= {str(stateJob['foldGroups'][-1])}"
-                                    , "    print(groupsOfFolds)"
-                                    , "    with numba.objmode():"
-                                    , f"        open('{pathFilenameFoldsTotal.as_posix()}', 'w').write(str(groupsOfFolds))"
-                                    , "    return groupsOfFolds"
-                                    ])
-
-    linesAll = "\n".join([
-                        linesImport
-                        , linesAlgorithm
-                        , linesWriteFoldsTotal
-                        , linesLaunch
-                        ])
-
-    pathFilenameDestination = pathFilenameFoldsTotal.with_suffix(".py")
-    pathFilenameDestination.write_text(linesAll)
-
-    return pathFilenameDestination
-
-if __name__ == '__main__':
-    listDimensions = [5,5]
-    setDatatypeFoldsTotal('int64', sourGrapes=True)
-    setDatatypeElephino('uint8', sourGrapes=True)
-    setDatatypeLeavesTotal('int8', sourGrapes=True)
-    pathFilenameModule = writeModuleWithNumba(listDimensions)
-
-    # Induce numba.jit compilation
-    moduleSpec = importlib.util.spec_from_file_location(pathFilenameModule.stem, pathFilenameModule)
-    if moduleSpec is None: raise ImportError(f"Could not load module specification from {pathFilenameModule}")
-    module = importlib.util.module_from_spec(moduleSpec)
-    if moduleSpec.loader is None: raise ImportError(f"Could not load module from {moduleSpec}")
-    moduleSpec.loader.exec_module(module)

mapFolding/syntheticModules/__init__.py

@@ -1,3 +0,0 @@
-from .numba_countInitialize import countInitialize
-from .numba_countParallel import countParallel
-from .numba_countSequential import countSequential

mapFolding-0.3.9.dist-info/RECORD

@@ -1,40 +0,0 @@
-mapFolding/__init__.py,sha256=UWzkx8iO90WeetoipfAuHJisICTJNWN7t_Q8FRi8lok,833
-mapFolding/basecamp.py,sha256=2Zo4ayHfpfn6RRtsumDNRvV7UUHx0GInfNYmr8-G2b4,3988
-mapFolding/beDRY.py,sha256=otzEut41VWUiKkwM8ZE6_aduNDMGGXYsyjtNs6AcotA,17845
-mapFolding/oeis.py,sha256=fIJySN5fIsRS-TBNbpKQdk9XVlZ4xFY6uthWzZY1jRs,12567
-mapFolding/theDao.py,sha256=BlYx1h39ieZIkTOhvzMJ2MEI5tjB4dHyrbz0q3bJNDc,14418
-mapFolding/theSSOT.py,sha256=ZXKFglwfr3JH4yGH8NmS1DRpfyON3Wulx8lG5gITHD0,10219
-mapFolding/reference/flattened.py,sha256=6blZ2Y9G8mu1F3gV8SKndPE398t2VVFlsgKlyeJ765A,16538
-mapFolding/reference/hunterNumba.py,sha256=HWndRgsajOf76rbb2LDNEZ6itsdYbyV-k3wgOFjeR6c,7104
-mapFolding/reference/irvineJavaPort.py,sha256=Sj-63Z-OsGuDoEBXuxyjRrNmmyl0d7Yz_XuY7I47Oyg,4250
-mapFolding/reference/jax.py,sha256=rojyK80lOATtbzxjGOHWHZngQa47CXCLJHZwIdN2MwI,14955
-mapFolding/reference/lunnan.py,sha256=XEcql_gxvCCghb6Or3qwmPbn4IZUbZTaSmw_fUjRxZE,5037
-mapFolding/reference/lunnanNumpy.py,sha256=HqDgSwTOZA-G0oophOEfc4zs25Mv4yw2aoF1v8miOLk,4653
-mapFolding/reference/lunnanWhile.py,sha256=7NY2IKO5XBgol0aWWF_Fi-7oTL9pvu_z6lB0TF1uVHk,4063
-mapFolding/reference/rotatedEntryPoint.py,sha256=z0QyDQtnMvXNj5ntWzzJUQUMFm1-xHGLVhtYzwmczUI,11530
-mapFolding/reference/total_countPlus1vsPlusN.py,sha256=usenM8Yn_G1dqlPl7NKKkcnbohBZVZBXTQRm2S3_EDA,8106
-mapFolding/someAssemblyRequired/__init__.py,sha256=3JnAKXfaYPtmxV_4AnZ6KpCosT_0GFV5Nw7K8sz4-Uo,34
-mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=FtJzw2pZS3A4NimWdZsegXaU-vKeCw8m67kcfb5wvGM,894
-mapFolding/someAssemblyRequired/makeJob.py,sha256=uKonSGmE4ieTpfqmIiYvVW05F3YN70eiUYJi-bj6yR8,2622
-mapFolding/someAssemblyRequired/synthesizeModuleJAX.py,sha256=43h_gOk0pCI8dITIRJ9_DBOwx4-KV5dQpw1MWRSoxE8,1355
-mapFolding/someAssemblyRequired/synthesizeModuleJobNumba.py,sha256=TCYNNI19vCw0C1FLP691VPpYknkedj-zpx-xQFVIVJU,9851
-mapFolding/someAssemblyRequired/synthesizeModulesNumba.py,sha256=EpIpJnCIZ6jQ0nwyw01ULM_55cAc0kM3YSLxRB2I5A0,25481
-mapFolding/syntheticModules/__init__.py,sha256=cER6gqkGb3SCHHE35AVjf14_ehUroXPjlM6Ot-TIt5w,149
-mapFolding/syntheticModules/numba_countInitialize.py,sha256=WTXIETx8EOncMRGzOJzDepoHkNCP25eaQAKfAIleaVs,4065
-mapFolding/syntheticModules/numba_countParallel.py,sha256=lMf2dtSTPoVLHT5yXemdSiXPMbdCdXJvVdLgVf_SVxM,5493
-mapFolding/syntheticModules/numba_countSequential.py,sha256=RjO4yAH9Qu0OJC6moECJ7JTDIRNXr5mlm6wrusGr-Og,3670
-mapFolding/syntheticModules/numba_doTheNeedful.py,sha256=iUbjbIlvoa--fK6f2tiGjaHA93E1v5jSnJUakE_5UTg,2465
-tests/__init__.py,sha256=eg9smg-6VblOr0kisM40CpGnuDtU2JgEEWGDTFVOlW8,57
-tests/conftest.py,sha256=4KuPXvkgYDZKWhxZlwRgnoLynMvmlnGLK8j2iqTX_9E,9044
-tests/conftest_tmpRegistry.py,sha256=0XpGe7s2aJcjdEAqKs10vceW0_JAaK-Rp1UoPaL-BIo,2450
-tests/conftest_uniformTests.py,sha256=2v9UJbKgbrus3UyWXsanEHLksBskbnP0MD8iKVPaIBo,2178
-tests/test_oeis.py,sha256=xIyU88nyEfeBK5TS4NfeBBy3YErgM1rGwVSu4ry-XrU,8491
-tests/test_other.py,sha256=yHGhoZfKh_Z-MZHXZknHC_FBm3sS9Cntr94_L9LLLhQ,12151
-tests/test_tasks.py,sha256=ap_tKjHUN95vjzKo3xzBAQ3kMbdMJ_XXbOv9YIBJ5pY,2826
-tests/test_types.py,sha256=HklNCGThFiqQ89AOMkE7YkcfAPiZE32DpD3GMDUPQVc,177
-mapFolding-0.3.9.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-mapFolding-0.3.9.dist-info/METADATA,sha256=NnN8fZG_zufvXSK5XC8Yrw0SmLwihDjFZlpIutqj-lc,7935
-mapFolding-0.3.9.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.3.9.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.3.9.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapFolding-0.3.9.dist-info/RECORD,,