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

tests/test_other.py

@@ -0,0 +1,258 @@
+from contextlib import redirect_stdout
+from tests.conftest import *
+from typing import Dict, List, Optional, Any, Tuple, Literal, Callable, Generator
+from Z0Z_tools import intInnit
+import io
+import itertools
+import numba
+import numpy
+import pathlib
+import pytest
+import random
+import sys
+
+@pytest.mark.parametrize("listDimensions,expected_intInnit,expected_parseListDimensions,expected_validateListDimensions,expected_getLeavesTotal", [
+    (None, ValueError, ValueError, ValueError, ValueError),  # None instead of list
+    (['a'], ValueError, ValueError, ValueError, ValueError),  # string
+    ([-4, 2], [-4, 2], ValueError, ValueError, ValueError),  # negative
+    ([-3], [-3], ValueError, ValueError, ValueError),  # negative
+    ([0, 0], [0, 0], [0, 0], NotImplementedError, 0),  # no positive dimensions
+    ([0, 5, 6], [0, 5, 6], [0, 5, 6], [5, 6], 30),  # zeros ignored
+    ([0], [0], [0], NotImplementedError, 0),  # edge case
+    ([1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], 120),  # sequential
+    ([1, sys.maxsize], [1, sys.maxsize], [1, sys.maxsize], [1, sys.maxsize], sys.maxsize),  # maxint
+    ([7.5], ValueError, ValueError, ValueError, ValueError),  # float
+    ([1] * 1000, [1] * 1000, [1] * 1000, [1] * 1000, 1),  # long list
+    ([11], [11], [11], NotImplementedError, 11),  # single dimension
+    ([13, 0, 17], [13, 0, 17], [13, 0, 17], [13, 17], 221),  # zeros handled
+    ([2, 2, 2, 2], [2, 2, 2, 2], [2, 2, 2, 2], [2, 2, 2, 2], 16),  # repeated dimensions
+    ([2, 3, 4], [2, 3, 4], [2, 3, 4], [2, 3, 4], 24),
+    ([2, 3], [2, 3], [2, 3], [2, 3], 6),
+    ([2] * 11, [2] * 11, [2] * 11, [2] * 11, 2048),  # power of 2
+    ([3, 2], [3, 2], [3, 2], [2, 3], 6),  # return value is the input when valid
+    ([3] * 5, [3] * 5, [3] * 5, [3, 3, 3, 3, 3], 243),  # power of 3
+    ([None], TypeError, TypeError, TypeError, TypeError),  # None
+    ([True], TypeError, TypeError, TypeError, TypeError),  # bool
+    ([[17, 39]], TypeError, TypeError, TypeError, TypeError),  # nested
+    ([], ValueError, ValueError, ValueError, ValueError),  # empty
+    ([complex(1,1)], ValueError, ValueError, ValueError, ValueError),  # complex number
+    ([float('inf')], ValueError, ValueError, ValueError, ValueError),  # infinity
+    ([float('nan')], ValueError, ValueError, ValueError, ValueError),  # NaN
+    ([sys.maxsize - 1, 1], [sys.maxsize - 1, 1], [sys.maxsize - 1, 1], [1, sys.maxsize - 1], sys.maxsize - 1),  # near maxint
+    ([sys.maxsize // 2, sys.maxsize // 2, 2], [sys.maxsize // 2, sys.maxsize // 2, 2], [sys.maxsize // 2, sys.maxsize // 2, 2], [2, sys.maxsize // 2, sys.maxsize // 2], OverflowError),  # overflow protection
+    ([sys.maxsize, sys.maxsize], [sys.maxsize, sys.maxsize], [sys.maxsize, sys.maxsize], [sys.maxsize, sys.maxsize], OverflowError),  # overflow protection
+    (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:
+    """Test both validateListDimensions and getLeavesTotal with the same inputs."""
+    standardizedEqualTo(expected_intInnit, intInnit, listDimensions)
+    standardizedEqualTo(expected_parseListDimensions, parseDimensions, listDimensions)
+    standardizedEqualTo(expected_validateListDimensions, validateListDimensions, listDimensions)
+    standardizedEqualTo(expected_getLeavesTotal, getLeavesTotal, listDimensions)
+
+def test_getLeavesTotal_edge_cases() -> None:
+    """Test edge cases for getLeavesTotal."""
+    # Order independence
+    standardizedEqualTo(getLeavesTotal([2, 3, 4]), getLeavesTotal, [4, 2, 3])
+
+    # Immutability
+    listOriginal = [2, 3]
+    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())
+
+@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_intInnit())
+def testIntInnit(nameOfTest: str, callablePytest: Callable[[], None]) -> None:
+    callablePytest()
+
+@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_oopsieKwargsie())
+def testOopsieKwargsie(nameOfTest: str, callablePytest: Callable[[], None]) -> None:
+    callablePytest()
+
+@pytest.mark.parametrize("CPUlimit, expectedLimit", [
+    (None, numba.get_num_threads()),
+    (False, numba.get_num_threads()),
+    (True, 1),
+    (4, 4),
+    (0.5, max(1, numba.get_num_threads() // 2)),
+    (-0.5, max(1, numba.get_num_threads() // 2)),
+    (-2, max(1, numba.get_num_threads() - 2)),
+    (0, numba.get_num_threads()),
+    (1, 1),
+])
+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:
+    connectionGraph = makeConnectionGraph(listDimensionsTestFunctionality)
+    assert numpy.all(connectionGraph >= 0), "All values in the connection graph should be non-negative."
+
+# @pytest.mark.parametrize("datatype", ['int16', '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}."
+
+"""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
+
+datatypeMedium
+    None
+    numpy.int64
+    numpy.intc
+    numpy.uint16
+
+datatypeLarge
+    None
+    numpy.int64
+    numpy.intp
+    numpy.uint32
+
+"""
+
+@pytest.fixture
+def parameterIterator() -> Callable[[List[int]], Generator[Dict[str, Any], None, None]]:
+    """Generate random combinations of parameters for outfitCountFolds testing."""
+    parameterSets: Dict[str, List[Any]] = {
+        'computationDivisions': [
+            None,
+            'maximum',
+            'cpu',
+        ],
+        'CPUlimit': [
+            None, True, False, 0, 1, -1,
+        ],
+        'datatypeMedium': [
+            None,
+            numpy.int64,
+            numpy.intc,
+            numpy.uint16
+        ],
+        'datatypeLarge': [
+            None,
+            numpy.int64,
+            numpy.intp,
+            numpy.uint32
+        ]
+    }
+
+    def makeParametersDynamic(listDimensions: List[int]) -> Dict[str, List[Any]]:
+        """Add context-dependent parameter values."""
+        parametersDynamic = parameterSets.copy()
+        leavesTotal = getLeavesTotal(listDimensions)
+        concurrencyLimit = min(leavesTotal, 16)
+
+        # Add dynamic computationDivisions values
+        dynamicDivisions = [random.randint(2, leavesTotal-1) for iterator in range(3)]
+        parametersDynamic['computationDivisions'] = parametersDynamic['computationDivisions'] + dynamicDivisions
+
+        # 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'] = parametersDynamic['CPUlimit'] + parameterDynamicCPU
+
+        return parametersDynamic
+
+    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]
+
+        # 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
+
+# TODO refactor due to changes
+# def test_pathJobDEFAULT_colab() -> None:
+#     """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)
+
+def test_saveFoldsTotal_fallback(pathTempTesting: pathlib.Path) -> None:
+    foldsTotal = 123
+    pathFilename = pathTempTesting / "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."
+
+def test_makeDataContainer_default_datatype() -> None:
+    """Test that makeDataContainer uses dtypeLargeDEFAULT when no datatype is specified."""
+    testShape = (3, 4)
+    container = makeDataContainer(testShape)
+    assert container.dtype == hackSSOTdtype('dtypeFoldsTotal'), f"Expected datatype but got {container.dtype}"
+    assert container.shape == testShape, f"Expected shape {testShape}, but got {container.shape}"

tests/test_tasks.py

@@ -0,0 +1,44 @@
+from tests.conftest import *
+import pytest
+from typing import List, Dict, Literal, Tuple, Any
+
+# 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_algorithmSourceParallel(listDimensionsTestParallelization: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int], useAlgorithmDirectly: None) -> None:
+    standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
+
+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:
+    standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
+
+@pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_defineConcurrencyLimit())
+def test_defineConcurrencyLimit(nameOfTest: str, callablePytest: Callable[[], None]) -> None:
+    callablePytest()
+
+# @pytest.mark.parametrize("CPUlimitParameter", [{"invalid": True}, ["weird"]])
+# def test_countFolds_cpuLimitOopsie(listDimensionsTestFunctionality: List[int], CPUlimitParameter: Dict[str, bool] | List[str]) -> None:
+#     standardizedEqualTo((AttributeError or ValueError), countFolds, listDimensionsTestFunctionality, None, 'cpu', CPUlimitParameter)
+
+@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: 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", [
+    (2, "2"),  # string
+    (ValueError, [4]),  # list
+    (ValueError, (2,)), # tuple
+    (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:
+    """Test that invalid CPUlimit types are properly handled."""
+    standardizedEqualTo(expected, setCPUlimit, parameter)

tests/test_types.py

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

benchmarks/benchmarking.py

@@ -1,67 +0,0 @@
-"""An incompetent benchmarking module for mapFolding."""
-from typing import Callable
-import multiprocessing
-import numpy
-import pathlib
-import time
-
-pathRecordedBenchmarks = pathlib.Path('mapFolding/benchmarks/marks')
-pathRecordedBenchmarks.mkdir(parents=True, exist_ok=True)
-pathFilenameRecordedBenchmarks = pathRecordedBenchmarks / "benchmarks.npy"
-
-def recordBenchmarks():
-    """Decorator to benchmark a function."""
-    def AzeemTheWrapper(functionTarget: Callable):
-        def djZeph(*arguments, **keywordArguments):
-            timeStart = time.perf_counter_ns()
-            returnValueTarget = functionTarget(*arguments, **keywordArguments)
-            timeElapsed = (time.perf_counter_ns() - timeStart) / 1e9
-
-            # Extract mapShape from arguments
-            mapShape = keywordArguments['mapShape']
-            # mapShape = tuple(arguments)[2]
-            # leavesTotal = tuple(arguments[3])[4]
-
-            # Store benchmark data in single file
-            benchmarkEntry = numpy.array([(timeElapsed, mapShape)], dtype=[('time', 'f8'), ('mapShape', 'O')])
-            # benchmarkEntry = numpy.array([(timeElapsed, leavesTotal)], dtype=[('time', 'f8'), ('leaves', 'O')])
-
-            if pathFilenameRecordedBenchmarks.exists():
-                arrayExisting = numpy.load(str(pathFilenameRecordedBenchmarks), allow_pickle=True)
-                arrayBenchmark = numpy.concatenate([arrayExisting, benchmarkEntry])
-            else:
-                arrayBenchmark = benchmarkEntry
-
-            numpy.save(str(pathFilenameRecordedBenchmarks), arrayBenchmark)
-            return returnValueTarget
-
-        return djZeph
-    return AzeemTheWrapper
-
-def runBenchmarks(benchmarkIterations: int = 30) -> None:
-    """Run benchmark iterations.
-
-    Parameters:
-        benchmarkIterations (30): Number of benchmark iterations to run
-    """
-    # TODO warmUp (False): Whether to perform one warm-up iteration
-
-    import itertools
-    from tqdm.auto import tqdm
-    from mapFolding.oeis import settingsOEIS, oeisIDfor_n
-    from concurrent.futures import ProcessPoolExecutor, as_completed
-    max_workers = 6
-
-    listParametersOEIS = [(oeisIdentifier, dimensionValue) for oeisIdentifier, settings in settingsOEIS.items() for dimensionValue in settings['valuesBenchmark']]
-    # for (oeisIdentifier, dimensionValue), iterationIndex in tqdm(itertools.product(listParametersOEIS, range(benchmarkIterations)), total=len(listParametersOEIS) * benchmarkIterations):
-    #     oeisIDfor_n(oeisIdentifier, dimensionValue)
-    listCartesianProduct = list(itertools.product(listParametersOEIS, range(benchmarkIterations)))
-    with ProcessPoolExecutor(max_workers) as concurrencyManager:
-        listConcurrency = [concurrencyManager.submit(oeisIDfor_n, *parameters[0]) for parameters in listCartesianProduct]
-        for _complete in tqdm(as_completed(listConcurrency), total=len(listCartesianProduct)):
-            pass
-
-if __name__ == '__main__':
-    multiprocessing.set_start_method('spawn')
-    pathFilenameRecordedBenchmarks.unlink(missing_ok=True)
-    runBenchmarks(30)

citations/updateCitation.py

@@ -1,238 +0,0 @@
-from cffconvert.cli.create_citation import create_citation
-from packaging.metadata import Metadata as PyPAMetadata
-from typing import Any, Dict, List
-import attrs
-import cffconvert
-import tempfile
-import packaging
-import packaging.metadata
-import packaging.utils
-import packaging.version
-import pathlib
-import ruamel.yaml
-import tomli
-
-listProjectURLsTarget: List[str] = ["homepage", "license", "repository"]
-
-"""
-Tentative plan:
-- Commit and push to GitHub
-- GitHub Action gathers information from the sources of truth
-- If the citation needs to be updated, write to both
-    - pathFilenameCitationSSOT
-    - pathFilenameCitationDOTcffRepo
-- Commit and push to GitHub
-    - this complicates things
-    - I want the updated citation to be in the `commit` field of itself
-"""
-
-@attrs.define
-class CitationNexus:
-    """
-    - one-to-one correlation with `cffconvert.lib.cff_1_2_x.citation` class Citation_1_2_x.cffobj
-    """
-    cffDASHversion: str # pathFilenameCitationSSOT
-    message: str # pathFilenameCitationSSOT
-
-    abstract: str | None = None # pathFilenameCitationSSOT
-    authors: list[dict[str,str]] = attrs.field(factory=list) # pathFilenamePackageSSOT; pyproject.toml authors
-    commit: str | None = None # workflows['Make GitHub Release']
-    contact: list[dict[str,str]] = attrs.field(factory=list) # pathFilenamePackageSSOT; pyproject.toml maintainers
-    dateDASHreleased: str | None = None # workflows['Make GitHub Release']
-    doi: str | None = None # pathFilenameCitationSSOT
-    identifiers: list[str] = attrs.field(factory=list) # workflows['Make GitHub Release']
-    keywords: list[str] = attrs.field(factory=list) # pathFilenamePackageSSOT; packaging.metadata.Metadata.keywords
-    license: str | None = None # pathFilenamePackageSSOT; packaging.metadata.Metadata.license_expression
-    licenseDASHurl: str | None = None # pathFilenamePackageSSOT; packaging.metadata.Metadata.project_urls: license or pyproject.toml urls license
-    preferredDASHcitation: str | None = None # pathFilenameCitationSSOT
-    references: list[str] = attrs.field(factory=list) # bibtex files in pathCitationSSOT. Conversion method and timing TBD.
-    repositoryDASHartifact: str | None = None # (https://pypi.org/pypi/{package_name}/json').json()['releases']
-    repositoryDASHcode: str | None = None # workflows['Make GitHub Release']
-    repository: str | None = None # pathFilenamePackageSSOT; packaging.metadata.Metadata.project_urls: repository
-    title: str | None = None # pathFilenamePackageSSOT; pyproject.toml name (packaging normalizes the names)
-    type: str | None = None # pathFilenameCitationSSOT
-    url: str | None = None # pathFilenamePackageSSOT; packaging.metadata.Metadata.project_urls: homepage
-    version: str | None = None # pathFilenamePackageSSOT; packaging.metadata.Metadata.version
-
-    def setInStone(self, prophet: str) -> "CitationNexus":
-        match prophet:
-            case "Citation":
-                pass
-                # "freeze" these items
-                # setattr(self.cffDASHversion, 'type', Final[str])
-                # setattr(self.doi, 'type', Final[str])
-                # cffDASHversion: str # pathFilenameCitationSSOT
-                # message: str # pathFilenameCitationSSOT
-                # abstract: str | None = None # pathFilenameCitationSSOT
-                # doi: str | None = None # pathFilenameCitationSSOT
-                # preferredDASHcitation: str | None = None # pathFilenameCitationSSOT
-                # type: str | None = None # pathFilenameCitationSSOT
-            case "PyPA":
-                pass
-                # "freeze" these items
-                # setattr(self.keywords, 'type', Final[list[str]])
-                # setattr(self.license, 'type', Final[str])
-                # setattr(self.licenseDASHurl, 'type', Final[str])
-                # setattr(self.repository, 'type', Final[str])
-                # setattr(self.url, 'type', Final[str])
-                # setattr(self.version, 'type', Final[str])
-            case "pyprojectDOTtoml":
-                pass
-                # "freeze" these items
-                # setattr(self.authors, 'type', Final[list[dict[str,str]]])
-                # setattr(self.contact, 'type', Final[list[dict[str,str]]])
-                # setattr(self.title, 'type', Final[str])
-        return self
-
-def getNexusCitation(pathFilenameCitationSSOT: pathlib.Path) -> CitationNexus:
-
-    # `cffconvert.cli.create_citation.create_citation()` is PAINFULLY mundane, but a major problem
-    # in the CFF ecosystem is divergence. Therefore, I will use this function so that my code
-    # converges with the CFF ecosystem.
-    citationObject: cffconvert.Citation = create_citation(infile=pathFilenameCitationSSOT, url=None)
-    # `._parse()` is a yaml loader: use it for convergence
-    cffobj: Dict[Any, Any] = citationObject._parse()
-
-    nexusCitation = CitationNexus(
-        cffDASHversion=cffobj["cff-version"],
-        message=cffobj["message"],
-    )
-
-    Z0Z_list: List[attrs.Attribute] = list(attrs.fields(type(nexusCitation)))
-    for Z0Z_field in Z0Z_list:
-        cffobjKeyName: str = Z0Z_field.name.replace("DASH", "-")
-        cffobjValue = cffobj.get(cffobjKeyName)
-        if cffobjValue: # An empty list will be False
-            setattr(nexusCitation, Z0Z_field.name, cffobjValue)
-
-    nexusCitation = nexusCitation.setInStone("Citation")
-    return nexusCitation
-
-def getPypaMetadata(packageData: Dict[str, Any]) -> PyPAMetadata:
-    """
-    Create a PyPA metadata object (version 2.4) from packageData.
-    https://packaging.python.org/en/latest/specifications/core-metadata/
-    """
-    dictionaryProjectURLs: Dict[str, str] = {}
-    for urlName, url in packageData.get("urls", {}).items():
-        urlName = urlName.lower()
-        if urlName in listProjectURLsTarget:
-            dictionaryProjectURLs[urlName] = url
-
-    metadataRaw = packaging.metadata.RawMetadata(
-        keywords=packageData.get("keywords", []),
-        license_expression=packageData.get("license", {}).get("text", ""),
-        metadata_version="2.4",
-        name=packaging.utils.canonicalize_name(packageData.get("name", None), validate=True), # packaging.metadata.InvalidMetadata: 'name' is a required field
-        project_urls=dictionaryProjectURLs,
-        version=packageData.get("version", None),
-    )
-
-    metadata = PyPAMetadata().from_raw(metadataRaw)
-    return metadata
-
-def addPypaMetadata(nexusCitation: CitationNexus, metadata: PyPAMetadata) -> CitationNexus:
-    if not metadata.name:
-        raise ValueError("Metadata name is required.")
-
-    nexusCitation.title = metadata.name
-    if metadata.version: nexusCitation.version = str(metadata.version)
-    if metadata.keywords: nexusCitation.keywords = metadata.keywords
-    if metadata.license_expression: nexusCitation.license = metadata.license_expression
-
-    Z0Z_lookup: Dict[str, str] = {
-        "homepage": "url",
-        "license": "licenseDASHurl",
-        "repository": "repository",
-    }
-    if metadata.project_urls:
-        for urlTarget in listProjectURLsTarget:
-            url = metadata.project_urls.get(urlTarget, None)
-            if url:
-                setattr(nexusCitation, Z0Z_lookup[urlTarget], url)
-
-    nexusCitation = nexusCitation.setInStone("PyPA")
-    return nexusCitation
-
-def add_pyprojectDOTtoml(nexusCitation: CitationNexus, packageData: Dict[str, Any]) -> CitationNexus:
-    def Z0Z_ImaNotValidatingNoNames(person: Dict[str, str]) -> Dict[str, str]:
-        cffPerson: Dict[str, str] = {}
-        if person.get('name', None):
-            cffPerson['given-names'], cffPerson['family-names'] = person['name'].split(' ', 1)
-        if person.get('email', None):
-            cffPerson['email'] = person['email']
-        return cffPerson
-    listAuthors = packageData.get("authors", None)
-    if not listAuthors:
-        raise ValueError("Authors are required.")
-    else:
-        listPersons = []
-        for person in listAuthors:
-            listPersons.append(Z0Z_ImaNotValidatingNoNames(person))
-            nexusCitation.authors = listPersons
-    if packageData.get("maintainers", None):
-        listPersons = []
-        for person in packageData["maintainers"]:
-            listPersons.append(Z0Z_ImaNotValidatingNoNames(person))
-            nexusCitation.contact = listPersons
-    nexusCitation.title = packageData["name"]
-    nexusCitation = nexusCitation.setInStone("pyprojectDOTtoml")
-    return nexusCitation
-
-def writeCitation(nexusCitation: CitationNexus, pathFilenameCitationSSOT: pathlib.Path, pathFilenameCitationDOTcffRepo: pathlib.Path):
-    # NOTE embarrassingly hacky process to follow
-    parameterIndent= 2
-    parameterLineWidth = 60
-    yamlWorkhorse = ruamel.yaml.YAML()
-
-    def srsly(Z0Z_filed, Z0Z_value):
-        if Z0Z_value: # empty lists
-            return True
-        else:
-            return False
-
-    dictionaryCitation = attrs.asdict(nexusCitation, filter=srsly)
-    for keyName in list(dictionaryCitation.keys()):
-        dictionaryCitation[keyName.replace("DASH", "-")] = dictionaryCitation.pop(keyName)
-
-    pathFilenameForValidation = pathlib.Path(tempfile.mktemp())
-
-    def writeStream(pathFilename):
-        with open(pathFilename, 'w') as pathlibIsAStealthContextManagerThatRuamelCannotDetectAndRefusesToWorkWith:
-            yamlWorkhorse.dump(dictionaryCitation, pathlibIsAStealthContextManagerThatRuamelCannotDetectAndRefusesToWorkWith)
-
-    writeStream(pathFilenameForValidation)
-
-    citationObject: cffconvert.Citation = create_citation(infile=pathFilenameForValidation, url=None)
-    if citationObject.validate(verbose=True) is None:
-        writeStream(pathFilenameCitationSSOT)
-        writeStream(pathFilenameCitationDOTcffRepo)
-
-def logistics():
-    # Prefer reliable, dynamic values over hardcoded ones
-    packageNameHARDCODED: str = 'mapFolding'
-
-    packageName: str = packageNameHARDCODED
-    pathRepoRoot = pathlib.Path(__file__).parent.parent.parent
-    pathFilenamePackageSSOT = pathRepoRoot / 'pyproject.toml'
-    filenameGitHubAction = 'updateCitation.yml'
-    pathFilenameGitHubAction = pathRepoRoot / '.github' / 'workflows' / filenameGitHubAction
-
-    filenameCitationDOTcff = 'CITATION.cff'
-    pathCitations = pathRepoRoot / packageName / 'citations'
-    pathFilenameCitationSSOT = pathCitations / filenameCitationDOTcff
-    pathFilenameCitationDOTcffRepo = pathRepoRoot / filenameCitationDOTcff
-
-    nexusCitation = getNexusCitation(pathFilenameCitationSSOT)
-
-    tomlPackageData: Dict[str, Any] = tomli.loads(pathFilenamePackageSSOT.read_text())['project']
-    # https://packaging.python.org/en/latest/specifications/pyproject-toml/
-    pypaMetadata: PyPAMetadata = getPypaMetadata(tomlPackageData)
-
-    nexusCitation = addPypaMetadata(nexusCitation, pypaMetadata)
-    nexusCitation = add_pyprojectDOTtoml(nexusCitation, tomlPackageData)
-
-    writeCitation(nexusCitation, pathFilenameCitationSSOT, pathFilenameCitationDOTcffRepo)
-
-if __name__ == '__main__':
-    logistics()

mapFolding-0.3.7.dist-info/RECORD

@@ -1,25 +0,0 @@
-benchmarks/benchmarking.py,sha256=HD_0NSvuabblg94ftDre6LFnXShTe8MYj3hIodW-zV0,3076
-citations/updateCitation.py,sha256=2MI8wHzLZg8eg2tAkbtynXPttxg3tTrd5ezEZIVyW48,10956
-reference/flattened.py,sha256=6blZ2Y9G8mu1F3gV8SKndPE398t2VVFlsgKlyeJ765A,16538
-reference/hunterNumba.py,sha256=HWndRgsajOf76rbb2LDNEZ6itsdYbyV-k3wgOFjeR6c,7104
-reference/irvineJavaPort.py,sha256=Sj-63Z-OsGuDoEBXuxyjRrNmmyl0d7Yz_XuY7I47Oyg,4250
-reference/jax.py,sha256=rojyK80lOATtbzxjGOHWHZngQa47CXCLJHZwIdN2MwI,14955
-reference/lunnan.py,sha256=XEcql_gxvCCghb6Or3qwmPbn4IZUbZTaSmw_fUjRxZE,5037
-reference/lunnanNumpy.py,sha256=HqDgSwTOZA-G0oophOEfc4zs25Mv4yw2aoF1v8miOLk,4653
-reference/lunnanWhile.py,sha256=7NY2IKO5XBgol0aWWF_Fi-7oTL9pvu_z6lB0TF1uVHk,4063
-reference/rotatedEntryPoint.py,sha256=z0QyDQtnMvXNj5ntWzzJUQUMFm1-xHGLVhtYzwmczUI,11530
-reference/total_countPlus1vsPlusN.py,sha256=usenM8Yn_G1dqlPl7NKKkcnbohBZVZBXTQRm2S3_EDA,8106
-someAssemblyRequired/__init__.py,sha256=3JnAKXfaYPtmxV_4AnZ6KpCosT_0GFV5Nw7K8sz4-Uo,34
-someAssemblyRequired/getLLVMforNoReason.py,sha256=FtJzw2pZS3A4NimWdZsegXaU-vKeCw8m67kcfb5wvGM,894
-someAssemblyRequired/makeJob.py,sha256=RTC80FhDrR19GqHtEeo6GpmlWZQESuf8FXqBqVzdOpk,1465
-someAssemblyRequired/synthesizeModuleJob.py,sha256=n6_2LUO2mf4PUuzN357EJiTATFB1TIAMDMgE5JvkcB0,7426
-someAssemblyRequired/synthesizeModules.py,sha256=foxk-mG-HGVap2USiA3ppCyWWXUmkLFzQiKacp5DD9M,11569
-syntheticModules/Initialize.py,sha256=Ut6rWt08LQ-kP9y-r25hwJjW82lO2DQfLBijhkKGaUo,4024
-syntheticModules/Parallel.py,sha256=Kq1uo5kfeeczk871yxaagsaNz8zaM8GWy0S3hZAEQz4,5343
-syntheticModules/Sequential.py,sha256=8KDiuK977s8hkyNw5pCZPNi0RHWDoCxwOteZ8CLuIEM,3643
-syntheticModules/__init__.py,sha256=lUDBXOiislfP2sIxT13_GZgElaytoYqk0ODUsucMYew,117
-mapFolding-0.3.7.dist-info/METADATA,sha256=BnMb2zDVlBgxU57qquN7iLYDSRHMkGmsL0ovLA_2G7k,7729
-mapFolding-0.3.7.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.3.7.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.3.7.dist-info/top_level.txt,sha256=yVG9dNZywoaddcsUdEDg7o0XOBzJd_4Z-sDaXGHpiMY,69
-mapFolding-0.3.7.dist-info/RECORD,,

mapFolding-0.3.7.dist-info/top_level.txt

@@ -1,5 +0,0 @@
-benchmarks
-citations
-reference
-someAssemblyRequired
-syntheticModules