mapFolding 0.2.5__tar.gz → 0.2.7__tar.gz

{mapfolding-0.2.5 → mapfolding-0.2.7}/PKG-INFO

@@ -1,18 +1,32 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.2.5
+Version: 0.2.7
 Summary: Count distinct ways to fold a map (or a strip of stamps)
 Author-email: Hunter Hogan <HunterHogan@pm.me>
-Project-URL: homepage, https://github.com/hunterhogan/mapFolding
-Requires-Python: <3.13,>=3.10
+License: CC-BY-NC-4.0
+Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
+Project-URL: Donate, https://www.patreon.com/integrated
+Keywords: A001415,A001416,A001417,A001418,A195646,folding,map folding,OEIS,stamp folding
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Other Audience
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Typing :: Typed
+Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: numba
 Requires-Dist: numpy
-Requires-Dist: Z0Z-tools
+Requires-Dist: Z0Z_tools
 Provides-Extra: benchmark
-Requires-Dist: pandas; extra == "benchmark"
-Requires-Dist: jupyter; extra == "benchmark"
 Requires-Dist: ipywidgets; extra == "benchmark"
+Requires-Dist: jupyter; extra == "benchmark"
+Requires-Dist: pandas; extra == "benchmark"
 Requires-Dist: tqdm; extra == "benchmark"
 Provides-Extra: testing
 Requires-Dist: pytest; extra == "testing"
@@ -40,7 +54,7 @@ The directory [mapFolding/reference](https://github.com/hunterhogan/mapFolding/b
 
 ## Simple, easy usage based on OEIS IDs
 
-`mapFolding` directly implements some IDs from _The On-Line Encyclopedia of Integer Sequences_.
+`mapFolding` directly implements some IDs from _The On-Line Encyclopedia of Integer Sequences_ ([BibTex](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/citations/oeis.bibtex) citation).
 
 ### Usage: command line
 

{mapfolding-0.2.5 → mapfolding-0.2.7}/README.md

@@ -18,7 +18,7 @@ The directory [mapFolding/reference](https://github.com/hunterhogan/mapFolding/b
 
 ## Simple, easy usage based on OEIS IDs
 
-`mapFolding` directly implements some IDs from _The On-Line Encyclopedia of Integer Sequences_.
+`mapFolding` directly implements some IDs from _The On-Line Encyclopedia of Integer Sequences_ ([BibTex](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/citations/oeis.bibtex) citation).
 
 ### Usage: command line
 

{mapfolding-0.2.5 → mapfolding-0.2.7/mapFolding}/mapFolding.egg-info/PKG-INFO

@@ -1,18 +1,32 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.2.5
+Version: 0.2.7
 Summary: Count distinct ways to fold a map (or a strip of stamps)
 Author-email: Hunter Hogan <HunterHogan@pm.me>
-Project-URL: homepage, https://github.com/hunterhogan/mapFolding
-Requires-Python: <3.13,>=3.10
+License: CC-BY-NC-4.0
+Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
+Project-URL: Donate, https://www.patreon.com/integrated
+Keywords: A001415,A001416,A001417,A001418,A195646,folding,map folding,OEIS,stamp folding
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Other Audience
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Typing :: Typed
+Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
 Requires-Dist: numba
 Requires-Dist: numpy
-Requires-Dist: Z0Z-tools
+Requires-Dist: Z0Z_tools
 Provides-Extra: benchmark
-Requires-Dist: pandas; extra == "benchmark"
-Requires-Dist: jupyter; extra == "benchmark"
 Requires-Dist: ipywidgets; extra == "benchmark"
+Requires-Dist: jupyter; extra == "benchmark"
+Requires-Dist: pandas; extra == "benchmark"
 Requires-Dist: tqdm; extra == "benchmark"
 Provides-Extra: testing
 Requires-Dist: pytest; extra == "testing"
@@ -40,7 +54,7 @@ The directory [mapFolding/reference](https://github.com/hunterhogan/mapFolding/b
 
 ## Simple, easy usage based on OEIS IDs
 
-`mapFolding` directly implements some IDs from _The On-Line Encyclopedia of Integer Sequences_.
+`mapFolding` directly implements some IDs from _The On-Line Encyclopedia of Integer Sequences_ ([BibTex](https://github.com/hunterhogan/mapFolding/blob/main/mapFolding/citations/oeis.bibtex) citation).
 
 ### Usage: command line
 

{mapfolding-0.2.5 → mapfolding-0.2.7/mapFolding}/mapFolding.egg-info/SOURCES.txt

@@ -1,20 +1,12 @@
 README.md
 pyproject.toml
-mapFolding/__init__.py
-mapFolding/babbage.py
-mapFolding/beDRY.py
-mapFolding/importSelector.py
-mapFolding/lovelace.py
-mapFolding/oeis.py
-mapFolding/startHere.py
-mapFolding/theSSOT.py
-mapFolding.egg-info/PKG-INFO
-mapFolding.egg-info/SOURCES.txt
-mapFolding.egg-info/dependency_links.txt
-mapFolding.egg-info/entry_points.txt
-mapFolding.egg-info/requires.txt
-mapFolding.egg-info/top_level.txt
 mapFolding/benchmarks/benchmarking.py
+mapFolding/mapFolding.egg-info/PKG-INFO
+mapFolding/mapFolding.egg-info/SOURCES.txt
+mapFolding/mapFolding.egg-info/dependency_links.txt
+mapFolding/mapFolding.egg-info/entry_points.txt
+mapFolding/mapFolding.egg-info/requires.txt
+mapFolding/mapFolding.egg-info/top_level.txt
 mapFolding/reference/flattened.py
 mapFolding/reference/hunterNumba.py
 mapFolding/reference/irvineJavaPort.py
@@ -28,9 +20,6 @@ mapFolding/someAssemblyRequired/inlineAfunction.py
 mapFolding/someAssemblyRequired/jobsAndTasks.py
 mapFolding/someAssemblyRequired/makeNuitkaSource.py
 mapFolding/someAssemblyRequired/makeNumbaJob.py
-tests/__init__.py
-tests/conftest.py
-tests/pythons_idiotic_namespace.py
 tests/test_oeis.py
 tests/test_other.py
 tests/test_tasks.py

{mapfolding-0.2.5 → mapfolding-0.2.7/mapFolding}/mapFolding.egg-info/requires.txt

@@ -1,11 +1,11 @@
 numba
 numpy
-Z0Z-tools
+Z0Z_tools
 
 [benchmark]
-pandas
-jupyter
 ipywidgets
+jupyter
+pandas
 tqdm
 
 [testing]

mapfolding-0.2.7/mapFolding/mapFolding.egg-info/top_level.txt

@@ -0,0 +1,4 @@
+benchmarks
+citations
+reference
+someAssemblyRequired

{mapfolding-0.2.5 → mapfolding-0.2.7}/mapFolding/someAssemblyRequired/inlineAfunction.py

@@ -1,11 +1,11 @@
-from mapFolding import indexMy, indexThe, indexTrack
+from mapFolding import indexMy, indexTrack
 import ast
 import copy
 import pathlib
 
 def getDictionaryEnumValues():
     dictionaryEnumValues = {}
-    for enumIndex in [indexMy, indexThe, indexTrack]:
+    for enumIndex in [indexMy, indexTrack]:
         for memberName, memberValue in enumIndex._member_map_.items():
             dictionaryEnumValues[f"{enumIndex.__name__}.{memberName}.value"] = memberValue.value
     return dictionaryEnumValues
@@ -125,7 +125,7 @@ def Z0Z_inlineMapFolding():
 
     listPathFilenamesDestination: list[pathlib.Path] = []
     for callableTarget in listCallables:
-        pathFilenameDestination = pathFilenameSource.with_stem(callableTarget)
+        pathFilenameDestination = pathFilenameSource.parent / "someAssemblyRequired" / pathFilenameSource.with_stem(callableTarget).name
         codeInlined = inlineFunctions(codeSource, callableTarget, dictionaryEnumValues)
         pathFilenameDestination.write_text(codeInlined)
         listPathFilenamesDestination.append(pathFilenameDestination)

{mapfolding-0.2.5 → mapfolding-0.2.7}/mapFolding/someAssemblyRequired/jobsAndTasks.py

@@ -1,10 +1,10 @@
-from typing import Any, Optional, Sequence, Type, Union
+from typing import Any, Optional, Sequence, Type
 
 def Z0Z_makeJob(listDimensions: Sequence[int], **keywordArguments: Optional[Type[Any]]):
     from mapFolding import outfitCountFolds
     stateUniversal = outfitCountFolds(listDimensions, computationDivisions=None, CPUlimit=None, **keywordArguments)
-    from mapFolding.countInitialize import countInitialize
-    countInitialize(stateUniversal['connectionGraph'], stateUniversal['gapsWhere'], stateUniversal['my'], stateUniversal['the'], stateUniversal['track'])
+    from mapFolding.someAssemblyRequired.countInitializeNoNumba import countInitialize
+    countInitialize(stateUniversal['connectionGraph'], stateUniversal['gapsWhere'], stateUniversal['my'], stateUniversal['track'])
     from mapFolding import getPathFilenameFoldsTotal
     pathFilenameChopChop = getPathFilenameFoldsTotal(stateUniversal['mapShape'])
     import pathlib
@@ -35,11 +35,10 @@ def runJob(pathFilename):
     gapsWhere: numpy.ndarray = stateJob['gapsWhere']
     my: numpy.ndarray = stateJob['my']
     pathFilenameFoldsTotal: Final[Path] = stateJob['pathFilenameFoldsTotal']
-    the: Final[numpy.ndarray] = stateJob['the']
     track: numpy.ndarray = stateJob['track']
 
-    from mapFolding.countSequentialNoNumba import countSequential
-    countSequential(connectionGraph, foldsSubTotals, gapsWhere, my, the, track)
+    from mapFolding.someAssemblyRequired.countSequentialNoNumba import countSequential
+    countSequential(connectionGraph, foldsSubTotals, gapsWhere, my, track)
 
     print(foldsSubTotals.sum().item())
     Path(pathFilenameFoldsTotal).parent.mkdir(parents=True, exist_ok=True)

{mapfolding-0.2.5 → mapfolding-0.2.7}/mapFolding/someAssemblyRequired/makeNumbaJob.py

@@ -1,9 +1,12 @@
 """Create a python module hardcoded to compute a map's foldsTotal.
-NumPy ndarray.
-Numba optimized.
-Absolutely no other imports.
+- NumPy ndarray.
+- Numba optimized.
+- Absolutely no other imports.
+
+Can create LLVM IR from the module: of unknown utility.
 """
-from mapFolding import datatypeLarge, dtypeLarge, dtypeDefault
+# from mapFolding import dtypeDefault, dtypeSmall
+from mapFolding import make_dtype, datatypeLarge, dtypeLarge
 from mapFolding.someAssemblyRequired.inlineAfunction import Z0Z_inlineMapFolding
 from mapFolding.someAssemblyRequired.jobsAndTasks import Z0Z_makeJob
 import importlib
@@ -11,30 +14,51 @@ import llvmlite.binding
 import numpy
 import pathlib
 import pickle
+import python_minifier
 
-listDimensions = [3,7]
+listDimensions = [5,5]
 
 # NOTE this overwrites files
 Z0Z_inlineMapFolding()
 
 identifierCallableLaunch = "goGoGadgetAbsurdity"
 
-def archivistFormatsArrayToCode(arrayTarget: numpy.ndarray, identifierName: str) -> str:
-    """Format numpy array into a code string that recreates the array."""
-    arrayAsTypeStr = numpy.array2string(arrayTarget, threshold=10000, max_line_width=200, separator=',')
-    return f"{identifierName} = numpy.array({arrayAsTypeStr}, dtype=numpy.{arrayTarget.dtype})"
+def convertNDArrayToStr(arrayTarget: numpy.ndarray, identifierName: str) -> str:
+    arrayAsTypeStr = numpy.array2string(arrayTarget, threshold=100000, max_line_width=200, separator=',')
+    stringMinimized = python_minifier.minify(arrayAsTypeStr)
+    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))
+    return f"{identifierName} = numpy.array({stringMinimized}, dtype=numpy.{arrayTarget.dtype})"
 
 def writeModuleWithNumba(listDimensions):
     numpy_dtypeLarge = dtypeLarge
-    numpy_dtypeDefault = dtypeDefault
-
-    parametersNumba = f"numba.types.{datatypeLarge}(), cache=True, parallel=False, boundscheck=False, \
-        error_model='numpy', fastmath=True, nogil=True, nopython=True, _nrt=True, forceinline=True, \
-            inline=True, looplift=True, no_cfunc_wrapper=False, no_cpython_wrapper=False"
-
-    pathFilenameData = Z0Z_makeJob(listDimensions, datatypeDefault=numpy_dtypeDefault, datatypeLarge=numpy_dtypeLarge)
-
-    pathFilenameAlgorithm = pathlib.Path('/apps/mapFolding/mapFolding/countSequentialNoNumba.py')
+    # numpy_dtypeDefault = dtypeDefault
+    datatypeDefault = 'uint8'
+    numpy_dtypeDefault = make_dtype(datatypeDefault)
+    numpy_dtypeSmall = numpy_dtypeDefault
+    # forceinline=True might actually be useful
+    parametersNumba = f"numba.types.{datatypeLarge}(), \
+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, \
+"
+# no_cfunc_wrapper=True, \
+# no_cpython_wrapper=True, \
+
+    pathFilenameData = Z0Z_makeJob(listDimensions, datatypeDefault=numpy_dtypeDefault, datatypeLarge=numpy_dtypeLarge, datatypeSmall=numpy_dtypeSmall)
+
+    pathFilenameAlgorithm = pathlib.Path('/apps/mapFolding/mapFolding/someAssemblyRequired/countSequentialNoNumba.py')
     pathFilenameDestination = pathFilenameData.with_stem(pathFilenameData.parent.name).with_suffix(".py")
 
     lineNumba = f"@numba.jit({parametersNumba})"
@@ -49,16 +73,16 @@ def writeModuleWithNumba(listDimensions):
     ImaIndent = '    '
     linesDataDynamic = """"""
     linesDataDynamic = "\n".join([linesDataDynamic
-            , ImaIndent + archivistFormatsArrayToCode(stateJob['my'], 'my')
-            , ImaIndent + archivistFormatsArrayToCode(stateJob['foldsSubTotals'], 'foldsSubTotals')
-            , ImaIndent + archivistFormatsArrayToCode(stateJob['gapsWhere'], 'gapsWhere')
-            , ImaIndent + archivistFormatsArrayToCode(stateJob['track'], 'track')
+            , ImaIndent + f"foldsTotal = numba.types.{datatypeLarge}(0)"
+            , ImaIndent + convertNDArrayToStr(stateJob['my'], 'my')
+            , ImaIndent + convertNDArrayToStr(stateJob['foldGroups'], 'foldGroups')
+            , ImaIndent + convertNDArrayToStr(stateJob['gapsWhere'], 'gapsWhere')
+            , ImaIndent + convertNDArrayToStr(stateJob['track'], 'track')
             ])
 
     linesDataStatic = """"""
     linesDataStatic = "\n".join([linesDataStatic
-            , ImaIndent + archivistFormatsArrayToCode(stateJob['the'], 'the')
-            , ImaIndent + archivistFormatsArrayToCode(stateJob['connectionGraph'], 'connectionGraph')
+            , ImaIndent + convertNDArrayToStr(stateJob['connectionGraph'], 'connectionGraph')
             ])
 
     pathFilenameFoldsTotal: pathlib.Path = stateJob['pathFilenameFoldsTotal']
@@ -79,26 +103,28 @@ def writeModuleWithNumba(listDimensions):
                             , lineSource
                             ])
 
-    lineReturn = f"{ImaIndent}return foldsSubTotals.sum().item()"
-
     linesLaunch = """"""
     linesLaunch = linesLaunch + f"""
 if __name__ == '__main__':
-    foldsTotal = {identifierCallableLaunch}()"""
+    import time
+    timeStart = time.perf_counter()
+    {identifierCallableLaunch}()
+    print(time.perf_counter() - timeStart)"""
 
     linesWriteFoldsTotal = """"""
     linesWriteFoldsTotal = "\n".join([linesWriteFoldsTotal
+                                    , "    foldsTotal = foldGroups[0:-1].sum() * foldGroups[-1]"
                                     , "    print(foldsTotal)"
-                                    , f"    open('{pathFilenameFoldsTotal.as_posix()}', 'w').write(str(foldsTotal))"
+                                    , "    with numba.objmode():"
+                                    , f"        open('{pathFilenameFoldsTotal.as_posix()}', 'w').write(str(foldsTotal))"
+                                    , "    return foldsTotal"
                                     ])
 
     linesAll = "\n".join([
                         linesImport
                         , linesAlgorithm
-                        , f"{ImaIndent}print(foldsSubTotals.sum().item())"
-                        , lineReturn
-                        , linesLaunch
                         , linesWriteFoldsTotal
+                        , linesLaunch
                         ])
 
     pathFilenameDestination.write_text(linesAll)

mapfolding-0.2.7/pyproject.toml

@@ -0,0 +1,75 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+authors = [{ name = "Hunter Hogan", email = "HunterHogan@pm.me" }]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Intended Audience :: Education",
+    "Intended Audience :: End Users/Desktop",
+    "Intended Audience :: Other Audience",
+    "Intended Audience :: Science/Research",
+    "Natural Language :: English",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python",
+    "Topic :: Scientific/Engineering :: Mathematics",
+    "Typing :: Typed",
+]
+dependencies = ["numba", "numpy", "Z0Z_tools"]
+description = "Count distinct ways to fold a map (or a strip of stamps)"
+keywords = [
+    "A001415",
+    "A001416",
+    "A001417",
+    "A001418",
+    "A195646",
+    "folding",
+    "map folding",
+    "OEIS",
+    "stamp folding",
+]
+license = { text = "CC-BY-NC-4.0" }
+name = "mapFolding"
+optional-dependencies = { benchmark = [
+    "ipywidgets",
+    "jupyter",
+    "pandas",
+    "tqdm",
+], testing = [
+    "pytest",
+    "pytest-cov",
+    "pytest-env",
+    "pytest-xdist",
+] }
+readme = { file = "README.md", content-type = "text/markdown" }
+requires-python = ">=3.10,<3.14"
+scripts = { getOEISids = "mapFolding.oeis:getOEISids", clearOEIScache = "mapFolding.oeis:clearOEIScache", OEIS_for_n = "mapFolding.oeis:OEIS_for_n" }
+urls = { Homepage = "https://github.com/hunterhogan/mapFolding", Donate = "https://www.patreon.com/integrated" }
+version = "0.2.7"
+
+[tool.coverage]
+report = { exclude_lines = [
+    "if TYPE_CHECKING:",
+    "if __name__ == \"__main__\":",
+    "numba.jit_module",
+], ignore_errors = false }
+run = { branch = true, concurrency = [
+    "multiprocessing",
+    "thread",
+], data_file = "tests/coverage/.coverage", omit = [
+    "tests/*",
+    "Z0Z_*",
+], parallel = true, source = [
+    "mapFolding",
+] }
+xml = { output = "tests/coverage/coverage.xml" }
+
+[tool.pytest.ini_options]
+addopts = ["--color=yes", "-n 4"]
+env = ["NUMBA_JIT_COVERAGE=1"]
+testpaths = ["tests"]
+
+[tool.setuptools.packages.find]
+where = ["mapFolding"]

{mapfolding-0.2.5 → mapfolding-0.2.7}/tests/test_other.py

@@ -1,7 +1,8 @@
 import pathlib
+from Z0Z_tools import intInnit
 from tests.conftest import *
 from tests.pythons_idiotic_namespace import *
-from typing import List, Optional
+from typing import List, Optional, Any
 import itertools
 import numba
 import numpy
@@ -9,6 +10,8 @@ import pytest
 import random
 import sys
 import unittest.mock
+import io
+from contextlib import redirect_stdout
 
 @pytest.mark.parametrize("listDimensions,expected_intInnit,expected_parseListDimensions,expected_validateListDimensions,expected_getLeavesTotal", [
     (None, ValueError, ValueError, ValueError, ValueError),  # None instead of list
@@ -81,23 +84,22 @@ def test_countFolds_writeFoldsTotal(
         pathWriteTarget = pathTempTesting / writeFoldsTarget
         filenameFoldsTotalExpected = writeFoldsTarget
 
+    foldsTotalExpected = foldsValue * getLeavesTotal(listDimensionsTestFunctionality)
     mock_countFolds = mockFoldingFunction(foldsValue, listDimensionsTestFunctionality)
 
     with unittest.mock.patch("mapFolding.babbage._countFolds", side_effect=mock_countFolds):
         returned = countFolds(listDimensionsTestFunctionality, pathishWriteFoldsTotal=pathWriteTarget)
 
-    standardComparison(foldsValue, lambda: returned)  # Check return value
-    standardComparison(str(foldsValue), lambda: (pathTempTesting / filenameFoldsTotalExpected).read_text())  # Check file content
+    # standardComparison(foldsValue, lambda: returned)  # Check return value
+    standardComparison(str(foldsTotalExpected), lambda: (pathTempTesting / filenameFoldsTotalExpected).read_text())  # Check file content
 
-def test_intInnit() -> None:
-    """Test integer parsing using the test suite generator."""
-    for testName, testFunction in makeTestSuiteIntInnit(intInnit).items():
-        testFunction()
+@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_intInnit())
+def testIntInnit(nameOfTest, callablePytest):
+    callablePytest()
 
-def test_oopsieKwargsie() -> None:
-    """Test handling of unexpected keyword arguments."""
-    for testName, testFunction in makeTestSuiteOopsieKwargsie(oopsieKwargsie).items():
-        testFunction()
+@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_oopsieKwargsie())
+def testOopsieKwargsie(nameOfTest, callablePytest):
+    callablePytest()
 
 @pytest.mark.parametrize("CPUlimit, expectedLimit", [
     (None, numba.config.NUMBA_DEFAULT_NUM_THREADS), # type: ignore
@@ -266,3 +268,14 @@ def test_pathJobDEFAULT_colab():
 
     # Reload one more time to restore original state
     importlib.reload(mapFolding.theSSOT)
+
+def test_saveFoldsTotal_fallback(pathTempTesting: pathlib.Path) -> None:
+    foldsTotal = 123
+    pathFilename = pathTempTesting / "unwritable" / "foldsTotal.txt"
+    with unittest.mock.patch("pathlib.Path.write_text", side_effect=OSError("Simulated write failure")):
+        with unittest.mock.patch("os.getcwd", return_value=str(pathTempTesting)):
+            capturedOutput = io.StringIO()
+            with redirect_stdout(capturedOutput):
+                saveFoldsTotal(pathFilename, foldsTotal)
+    fallbackFiles = list(pathTempTesting.glob("foldsTotalYO_*.txt"))
+    assert len(fallbackFiles) == 1, "Fallback file was not created upon write failure."

{mapfolding-0.2.5 → mapfolding-0.2.7}/tests/test_tasks.py

@@ -1,4 +1,4 @@
-from .conftest import *
+from tests.conftest import *
 import pytest
 from typing import List, Dict, Tuple
 
@@ -8,14 +8,13 @@ from typing import List, Dict, Tuple
 def test_countFolds_computationDivisions(listDimensionsTest_countFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]) -> None:
     standardComparison(foldsTotalKnown[tuple(listDimensionsTest_countFolds)], countFolds, listDimensionsTest_countFolds, None, 'maximum')
 
-def test_defineConcurrencyLimit() -> None:
-    testSuite = makeTestSuiteConcurrencyLimit(defineConcurrencyLimit)
-    for testName, testFunction in testSuite.items():
-        testFunction()
+@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_defineConcurrencyLimit())
+def testConcurrencyLimit(nameOfTest, callablePytest):
+    callablePytest()
 
-@pytest.mark.parametrize("CPUlimitParameter", [{"invalid": True}, ["weird"]])
-def test_countFolds_cpuLimitOopsie(listDimensionsTestFunctionality: List[int], CPUlimitParameter: Dict[str, bool] | List[str]) -> None:
-    standardComparison(ValueError, countFolds, listDimensionsTestFunctionality, None, 'cpu', CPUlimitParameter)
+# @pytest.mark.parametrize("CPUlimitParameter", [{"invalid": True}, ["weird"]])
+# def test_countFolds_cpuLimitOopsie(listDimensionsTestFunctionality: List[int], CPUlimitParameter: Dict[str, bool] | List[str]) -> None:
+#     standardComparison((AttributeError or ValueError), countFolds, listDimensionsTestFunctionality, None, 'cpu', CPUlimitParameter)
 
 def test_countFolds_invalid_computationDivisions(listDimensionsTestFunctionality: List[int]) -> None:
     standardComparison(ValueError, countFolds, listDimensionsTestFunctionality, None, {"wrong": "value"})

mapfolding-0.2.5/mapFolding/__init__.py

@@ -1,12 +0,0 @@
-from .theSSOT import *
-from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
-from .beDRY import getFilenameFoldsTotal, getPathFilenameFoldsTotal, outfitCountFolds, saveFoldsTotal
-from .startHere import countFolds
-from .oeis import oeisIDfor_n, getOEISids, clearOEIScache
-
-__all__ = [
-    'clearOEIScache',
-    'countFolds',
-    'getOEISids',
-    'oeisIDfor_n',
-]

mapfolding-0.2.5/mapFolding/babbage.py

@@ -1,35 +0,0 @@
-from mapFolding.importSelector import countSequential, countParallel, countInitialize
-from mapFolding import indexThe
-from numpy import integer
-from numpy.typing import NDArray
-from typing import Any, Tuple
-import numba
-import numpy
-
-@numba.jit(cache=True)
-def _countFolds(connectionGraph: NDArray[integer[Any]], foldsSubTotals: NDArray[integer[Any]], gapsWhere: NDArray[integer[Any]], mapShape: Tuple[int, ...], my: NDArray[integer[Any]], the: NDArray[integer[Any]], track: NDArray[integer[Any]]):
-    """
-    What in tarnation is this stupid module and function?
-
-    - This function is not in the same module as `countFolds` so that we can delay Numba just-in-time (jit) compilation of this function and the finalization of its settings until we are ready.
-    - This function is not in the same module as `countFoldsCompiled`, which is the function that does the hard, so that we can delay `numba.jit` compilation of `countFoldsCompiled`.
-    - `countFoldsCompiled` is not merely "jitted", it is super jitted, which makes it too arrogant to talk to plebian Python functions. It will, however, reluctantly talk to basic jitted functions.
-    - The function in this module is jitted, so it can talk to `countFoldsCompiled`, and because it isn't so arrogant, it will talk to the low-class `countFolds` with only a few restrictions, such as:
-        - No `TypedDict`
-        - No Python v 3.13
-        - The plebs must clean up their own memory problems
-        - No oversized integers
-        - No global variables, only global constants
-        - They don't except pleb nonlocal variables either
-        - Python "class": they are all inferior to a jit
-        - No `**kwargs`
-        - and just a few dozen-jillion other things.
-
-    """
-    # print("babbage")
-    countInitialize(connectionGraph=connectionGraph, gapsWhere=gapsWhere, my=my, the=the, track=track)
-
-    if the[indexThe.taskDivisions.value] > 0:
-        countParallel(connectionGraph=connectionGraph, foldsSubTotals=foldsSubTotals, gapsWherePARALLEL=gapsWhere, myPARALLEL=my, the=the, trackPARALLEL=track)
-    else:
-        countSequential(connectionGraph=connectionGraph, foldsSubTotals=foldsSubTotals, gapsWhere=gapsWhere, my=my, the=the, track=track)