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

tests/test_other.py

@@ -1,13 +1,14 @@
-from pathlib import Path
-from typing import List
-from .conftest import *
+import pathlib
+from tests.conftest import *
+from tests.pythons_idiotic_namespace import *
+from typing import List, Optional
+import itertools
+import numba
+import numpy
 import pytest
+import random
 import sys
 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
@@ -59,18 +60,34 @@ def test_getLeavesTotal_edge_cases() -> None:
     standardComparison(6, getLeavesTotal, listOriginal)
     standardComparison([2, 3], lambda x: x, listOriginal)  # Check that the list wasn't modified
 
-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())
+@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,
+    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
+
+    mock_countFolds = mockFoldingFunction(foldsValue, listDimensionsTestFunctionality)
 
-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())
+    with unittest.mock.patch("mapFolding.babbage._countFolds", side_effect=mock_countFolds):
+        returned = countFolds(listDimensionsTestFunctionality, writeFoldsTotal=pathWriteTarget)
+
+    standardComparison(foldsValue, lambda: returned)  # Check return value
+    standardComparison(str(foldsValue), lambda: (pathTempTesting / filenameFoldsTotalExpected).read_text())  # Check file content
 
 def test_intInnit() -> None:
     """Test integer parsing using the test suite generator."""
@@ -82,18 +99,19 @@ def test_oopsieKwargsie() -> None:
     for testName, testFunction in makeTestSuiteOopsieKwargsie(oopsieKwargsie).items():
         testFunction()
 
-# 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)
+@pytest.mark.parametrize("CPUlimit, expectedLimit", [
+    (None, numba.config.NUMBA_DEFAULT_NUM_THREADS), # type: ignore
+    (False, numba.config.NUMBA_DEFAULT_NUM_THREADS), # type: ignore
+    (True, 1),
+    (4, 4),
+    (0.5, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS // 2)), # type: ignore
+    (-0.5, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS // 2)), # type: ignore
+    (-2, max(1, numba.config.NUMBA_DEFAULT_NUM_THREADS - 2)), # type: ignore
+    (0, numba.config.NUMBA_DEFAULT_NUM_THREADS), # type: ignore
+    (1, 1),
+])
+def test_setCPUlimit(CPUlimit, expectedLimit) -> None:
+    standardComparison(expectedLimit, setCPUlimit, CPUlimit)
 
 def test_makeConnectionGraph_nonNegative(listDimensionsTestFunctionality: List[int]) -> None:
     connectionGraph = makeConnectionGraph(listDimensionsTestFunctionality)
@@ -103,3 +121,148 @@ def test_makeConnectionGraph_nonNegative(listDimensionsTestFunctionality: List[i
 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}."
+
+
+"""5 parameters
+listDimensionsTestFunctionality
+
+computationDivisions
+    None
+    random: int, first included: 2, first excluded: leavesTotal
+    maximum
+    cpu
+
+CPUlimit
+    None
+    True
+    False
+    0
+    1
+    -1
+    random: 0 < float < 1
+    random: -1 < float < 0
+    random: int, first included: 2, first excluded: (min(leavesTotal, 16) - 1)
+    random: int, first included: -1 * (min(leavesTotal, 16) - 1), first excluded: -1
+
+datatypeDefault
+    None
+    numpy.int64
+    numpy.intc
+    numpy.uint16
+
+datatypeLarge
+    None
+    numpy.int64
+    numpy.intp
+    numpy.uint32
+
+"""
+
+@pytest.fixture
+def parameterIterator():
+    """Generate random combinations of parameters for outfitCountFolds testing."""
+    parameterSets = {
+        'computationDivisions': [
+            None,
+            'maximum',
+            'cpu',
+        ],
+        'CPUlimit': [
+            None, True, False, 0, 1, -1,
+        ],
+        'datatypeDefault': [
+            None,
+            numpy.int64,
+            numpy.intc,
+            numpy.uint16
+        ],
+        'datatypeLarge': [
+            None,
+            numpy.int64,
+            numpy.intp,
+            numpy.uint32
+        ]
+    }
+
+    def makeParametersDynamic(listDimensions):
+        """Add context-dependent parameter values."""
+        parametersDynamic = parameterSets.copy()
+        leavesTotal = getLeavesTotal(listDimensions)
+        concurrencyLimit = min(leavesTotal, 16)
+
+        # Add dynamic computationDivisions
+        parametersDynamic['computationDivisions'].extend(
+            [random.randint(2, leavesTotal-1) for iterator in range(3)]
+        )
+
+        # Add dynamic CPUlimit values
+        parameterDynamicCPU = [
+            random.random(),  # 0 to 1
+            -random.random(), # -1 to 0
+        ]
+        parameterDynamicCPU.extend(
+            [random.randint(2, concurrencyLimit-1) for iterator in range(2)]
+        )
+        parameterDynamicCPU.extend(
+            [random.randint(-concurrencyLimit+1, -2) for iterator in range(2)]
+        )
+        parametersDynamic['CPUlimit'].extend(parameterDynamicCPU)
+
+        return parametersDynamic
+
+    def generateCombinations(listDimensions):
+        parametersDynamic = makeParametersDynamic(listDimensions)
+        parameterKeys = list(parametersDynamic.keys())
+        parameterValues = [parametersDynamic[key] for key in parameterKeys]
+
+        # Shuffle each parameter list
+        for valueList in parameterValues:
+            random.shuffle(valueList)
+
+        # Use zip_longest to iterate, filling with None when shorter lists are exhausted
+        for combination in itertools.zip_longest(*parameterValues, fillvalue=None):
+            yield dict(zip(parameterKeys, combination))
+
+    return generateCombinations
+
+def test_outfitCountFolds_basic(listDimensionsTestFunctionality, parameterIterator):
+    """Basic validation of outfitCountFolds return value structure."""
+    parameters = next(parameterIterator(listDimensionsTestFunctionality))
+
+    stateInitialized = outfitCountFolds(
+        listDimensionsTestFunctionality,
+        **{k: v for k, v in parameters.items() if v is not None}
+    )
+
+    # Basic structure tests
+    assert isinstance(stateInitialized, dict)
+    assert len(stateInitialized) == 7  # 6 ndarray + 1 tuple
+
+    # Check for specific keys
+    requiredKeys = set(computationState.__annotations__.keys())
+    assert set(stateInitialized.keys()) == requiredKeys
+
+    # Check types more carefully
+    for key, value in stateInitialized.items():
+        if key == 'mapShape':
+            assert isinstance(value, tuple)
+            assert all(isinstance(dim, int) for dim in value)
+        else:
+            assert isinstance(value, numpy.ndarray), f"{key} should be ndarray but is {type(value)}"
+            assert issubclass(value.dtype.type, numpy.integer), \
+                f"{key} should have integer dtype but has {value.dtype}"
+
+def test_pathJobDEFAULT_colab():
+    """Test that pathJobDEFAULT is set correctly when running in Google Colab."""
+    # Mock sys.modules to simulate running in Colab
+    with unittest.mock.patch.dict('sys.modules', {'google.colab': unittest.mock.MagicMock()}):
+        # Force reload of theSSOT to trigger Colab path logic
+        import importlib
+        import mapFolding.theSSOT
+        importlib.reload(mapFolding.theSSOT)
+
+        # Check that path was set to Colab-specific value
+        assert mapFolding.theSSOT.pathJobDEFAULT == pathlib.Path("/content/drive/MyDrive") / "jobs"
+
+    # Reload one more time to restore original state
+    importlib.reload(mapFolding.theSSOT)

tests/test_temporary.py

@@ -0,0 +1,25 @@
+from tests.conftest import *
+from typing import Dict, List, Tuple
+import importlib
+import pytest
+
+@pytest.fixture(scope="session", autouse=True)
+def runSecondSetAfterAll(request: pytest.FixtureRequest):
+    """Run after all other tests complete."""
+    def toggleAndRerun():
+        import mapFolding.importSelector
+        import mapFolding.babbage
+        mapFolding.importSelector.useLovelace = not mapFolding.importSelector.useLovelace
+        importlib.reload(mapFolding.importSelector)
+        importlib.reload(mapFolding.babbage)
+
+    request.addfinalizer(toggleAndRerun)
+
+@pytest.mark.order(after="runSecondSetAfterAll")
+def test_myabilitytodealwithbs(oeisID: str):
+    for n in settingsOEIS[oeisID]['valuesTestValidation']:
+        standardComparison(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
+
+@pytest.mark.order(after="runSecondSetAfterAll")
+def test_eff_em_el(listDimensionsTest_countFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]) -> None:
+    standardComparison(foldsTotalKnown[tuple(listDimensionsTest_countFolds)], countFolds, listDimensionsTest_countFolds, None, 'maximum')

mapFolding/benchmarks/test_benchmarks.py

@@ -1,74 +0,0 @@
-from ...tests.conftest import *
-from .benchmarking import recordBenchmarks, runBenchmarks
-import numpy
-import pathlib
-import pytest
-import unittest.mock
-from typing import List
-
-def test_recordBenchmarks_decorator(pathBenchmarksTesting: pathlib.Path,
-                                    listDimensionsTestFunctionality: List[int],
-                                    mockBenchmarkTimer: unittest.mock.MagicMock):
-    """Test that the decorator correctly records benchmark data."""
-    @recordBenchmarks()
-    def functionTest(listDimensions: List[int]) -> int:
-        return sum(listDimensions)
-
-    with mockBenchmarkTimer:
-        mockBenchmarkTimer.side_effect = [0, 1e9]
-        result = functionTest(listDimensionsTestFunctionality)
-
-    # Verify function still works normally
-    assert result == sum(listDimensionsTestFunctionality)
-
-    # Verify benchmark data was saved
-    arrayBenchmarks = numpy.load(str(pathBenchmarksTesting), allow_pickle=True)
-    assert len(arrayBenchmarks) == 1
-    assert arrayBenchmarks[0]['time'] == 1.0
-    assert tuple(arrayBenchmarks[0]['dimensions']) == tuple(listDimensionsTestFunctionality)
-
-def test_recordBenchmarks_multiple_calls(pathBenchmarksTesting: pathlib.Path,
-                                        listDimensionsTestFunctionality: List[int],
-                                        mockBenchmarkTimer: unittest.mock.MagicMock):
-    """Test that multiple function calls append to benchmark data."""
-    @recordBenchmarks()
-    def functionTest(listDimensions: List[int]) -> int:
-        return sum(listDimensions)
-
-    with mockBenchmarkTimer:
-        mockBenchmarkTimer.side_effect = [0, 1e9, 2e9, 4e9]
-        functionTest(listDimensionsTestFunctionality)
-        functionTest(listDimensionsTestFunctionality)
-
-    arrayBenchmarks = numpy.load(str(pathBenchmarksTesting), allow_pickle=True)
-    assert len(arrayBenchmarks) == 2
-    assert arrayBenchmarks[0]['time'] == 1.0
-    assert arrayBenchmarks[1]['time'] == 2.0
-
-# NOTE This test tries to collect benchmark data without ensuring that a function is decorated.
-# def test_runBenchmarks_integration(pathBenchmarksTesting: pathlib.Path, listDimensionsTestFunctionality: List[int]):
-#     """Test runBenchmarks creates valid benchmark data."""
-#     countIterations = 2
-#     runBenchmarks(countIterations)
-
-#     arrayBenchmarks = numpy.load(str(pathBenchmarksTesting), allow_pickle=True)
-#     assert len(arrayBenchmarks) > 0  # Should have recorded some benchmarks
-
-#     # Verify data structure integrity
-#     assert arrayBenchmarks.dtype.names == ('time', 'dimensions')
-#     assert all(isinstance(record['time'], float) for record in arrayBenchmarks)
-#     assert all(isinstance(record['dimensions'], tuple) for record in arrayBenchmarks)
-
-#     # Verify at least one benchmark entry matches our test dimensions
-#     assert any(tuple(listDimensionsTestFunctionality) == record['dimensions'] for record in arrayBenchmarks)
-
-# NOTE This test tries to collect benchmark data without ensuring that a function is decorated.
-# @pytest.mark.parametrize("countIterations", [1, 2])
-# def test_runBenchmarks_iterations(countIterations: int, pathBenchmarksTesting: pathlib.Path, listDimensionsTestFunctionality: List[int]):
-#     """Test runBenchmarks records data for each iteration."""
-#     runBenchmarks(countIterations)
-#     arrayBenchmarks = numpy.load(str(pathBenchmarksTesting), allow_pickle=True)
-
-#     # Should have at least countIterations entries for our test dimensions
-#     countMatches = sum(1 for record in arrayBenchmarks if tuple(listDimensionsTestFunctionality) == record['dimensions'])
-#     assert countMatches >= countIterations

mapFolding-0.2.2.dist-info/RECORD

@@ -1,28 +0,0 @@
-mapFolding/__init__.py,sha256=POxXTSE6Qu1G8k-YlSXHzbe-_JGuHk-L9p5SLRng4vA,439
-mapFolding/babbage.py,sha256=3D1qcntoiJm2tqgbiCAMc7GpGA0SZTdGORNEnensyxk,1882
-mapFolding/beDRY.py,sha256=ZrUXCNqnumTQ1XX8RT5gGdRr-a-o8QxEiGrerUxKtYg,12784
-mapFolding/lovelace.py,sha256=qcyGpVEPP3n0r-RNrSUgPRP3yZJfBEfmok7jYMm1OI0,11473
-mapFolding/oeis.py,sha256=_-fLGc1ybZ2eFxoiBrSmojMexeg6ROxtrLaBF2BzMn4,12144
-mapFolding/startHere.py,sha256=RGdFoJJdrJ_0tmLIKZn1WnHP0NCZwvQG7C2p4EUHOe4,5034
-mapFolding/theSSOT.py,sha256=yRW6aHyJxheL-Znk537LQA6xUPHz6FfoXY-0Ayh3Lsg,2178
-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=0giUyqAFzP-XKcq3Kz8wIWCK0BVFhjABVJ1s-w4Jhu0,7109
-mapFolding/reference/irvineJavaPort.py,sha256=Sj-63Z-OsGuDoEBXuxyjRrNmmyl0d7Yz_XuY7I47Oyg,4250
-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
-tests/__init__.py,sha256=PGYVr7r23gATgcvZ3Sfph9D_g1MVvhgzMNWXBs_9tmY,52
-tests/conftest.py,sha256=VFYSd7-tHWd-LUKnTY24PIJhq9quP9S3sK2SYusNNog,12875
-tests/test_oeis.py,sha256=vxnwO-cSR68htkyMh9QMVv-lvxBo6qlwPg1Rbx4JylY,7963
-tests/test_other.py,sha256=cf8DbkZxm_DHNq9lkMe7auXye_XspruU9qiNZATkxr4,6930
-tests/test_tasks.py,sha256=Nwe4iuSjwGZvsw5CXCcic7tkBxgM5JX9mrGZMDYhAwE,1785
-mapFolding-0.2.2.dist-info/METADATA,sha256=BSCXcKZDhAtOWr8A5pZMG8bZnm5YBLf-6uMN9qs8JDk,5914
-mapFolding-0.2.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.2.2.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.2.2.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapFolding-0.2.2.dist-info/RECORD,,