mapFolding 0.3.9__tar.gz → 0.3.11__tar.gz

{mapfolding-0.3.9 → mapfolding-0.3.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.9
+Version: 0.3.11
 Summary: Count distinct ways to fold a map (or a strip of stamps)
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -25,12 +25,8 @@ License-File: LICENSE
 Requires-Dist: numba
 Requires-Dist: numpy
 Requires-Dist: Z0Z_tools
-Provides-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: autoflake; extra == "testing"
 Requires-Dist: more_itertools; extra == "testing"
 Requires-Dist: mypy; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
@@ -39,8 +35,8 @@ Requires-Dist: pytest-mypy; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: python_minifier; extra == "testing"
-Requires-Dist: tomli; extra == "testing"
 Requires-Dist: types-setuptools; extra == "testing"
+Requires-Dist: updateCitation; extra == "testing"
 
 # Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)
 

{mapfolding-0.3.9 → mapfolding-0.3.11}/mapFolding/__init__.py

@@ -1,25 +1,43 @@
+# fundamentals
 from mapFolding.theSSOT import (
     computationState,
     EnumIndices,
-    getAlgorithmCallable,
-    getAlgorithmSource,
     getDispatcherCallable,
-    getPathJobDEFAULT,
     getPathPackage,
-    getPathSyntheticModules,
-    hackSSOTdatatype,
-    hackSSOTdtype,
     indexMy,
     indexTrack,
-    moduleOfSyntheticModules,
     myPackageNameIs,
-    ParametersNumba,
-    parametersNumbaDEFAULT,
+)
+
+# Datatype management
+from mapFolding.theSSOT import (
+    hackSSOTdatatype,
+    hackSSOTdtype,
     setDatatypeElephino,
     setDatatypeFoldsTotal,
     setDatatypeLeavesTotal,
     setDatatypeModule,
 )
+
+# Synthesize modules
+from mapFolding.theSSOT import (
+    getAlgorithmCallable,
+    getAlgorithmSource,
+    getPathJobRootDEFAULT,
+    getPathSyntheticModules,
+    moduleOfSyntheticModules,
+)
+
+# Parameters for the prima donna
+from mapFolding.theSSOT import (
+    ParametersNumba,
+    parametersNumbaDEFAULT,
+    parametersNumbaFailEarly,
+    parametersNumbaParallelDEFAULT,
+    parametersNumbaSuperJit,
+    parametersNumbaSuperJitParallel,
+)
+
 from mapFolding.beDRY import (
     getFilenameFoldsTotal,
     getPathFilenameFoldsTotal,

{mapfolding-0.3.9 → mapfolding-0.3.11}/mapFolding/basecamp.py

@@ -1,4 +1,4 @@
-from mapFolding import getDispatcherCallable, getPathFilenameFoldsTotal, outfitCountFolds, saveFoldsTotal, computationState
+from mapFolding import computationState, getDispatcherCallable, getPathFilenameFoldsTotal, outfitCountFolds, saveFoldsTotal
 from typing import Optional, Sequence, Union
 import os
 

{mapfolding-0.3.9 → mapfolding-0.3.11}/mapFolding/beDRY.py

@@ -1,8 +1,7 @@
 """A relatively stable API for oft-needed functionality."""
-from operator import ge
 from mapFolding import (
     computationState,
-    getPathJobDEFAULT,
+    getPathJobRootDEFAULT,
     hackSSOTdtype,
     indexMy,
     indexTrack,
@@ -11,9 +10,9 @@ from mapFolding import (
     setDatatypeLeavesTotal,
 )
 from numpy import integer
-from numpy.typing import NDArray, DTypeLike
+from numpy.typing import DTypeLike, NDArray
 from typing import Any, List, Optional, Sequence, Tuple, Type, Union
-from Z0Z_tools import intInnit, defineConcurrencyLimit, oopsieKwargsie
+from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
 import numba
 import numpy
 import os
@@ -21,18 +20,26 @@ import pathlib
 import sys
 
 def getFilenameFoldsTotal(mapShape: Union[Sequence[int], numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]]) -> str:
-    """Generate a standardized filename string for storing map folding totals.
-
-    The function takes a map shape sequence and converts it into a filename string
-    representing the dimensions of the map, followed by '.foldsTotal' extension.
-    For example, [3, 2] becomes 'p2x3.foldsTotal'.
+    """Make a standardized filename for the computed value `foldsTotal`.
+
+    The filename takes into account
+        - the dimensions of the map, aka `mapShape`, aka `listDimensions`
+        - no spaces in the filename
+        - safe filesystem characters across platforms
+        - unique extension
+        - avoiding potential problems when Python is manipulating the filename, including
+            - treating the file stem as a valid Python identifier, such as
+                - not starting with a number
+                - not using reserved words
+                - no dashes or other special characters
+            - uh, I can't remember, but I found some frustrating edge limitations
+        - if 'p' is still the first character, I picked that because it was the original identifier for the map shape in Lunnan's code
 
     Parameters:
-        mapShape: A sequence of integers representing the dimensions
-            of the map (e.g., [3, 2] for a 3x2 map)
+        mapShape: A sequence of integers representing the dimensions of the map (e.g., [3, 2] for a 3x2 map)
 
     Returns:
-        A filename string in format 'pNxM.foldsTotal' where N,M are sorted dimensions
+        filenameFoldsTotal: A filename string in format 'pNxM.foldsTotal' where N,M are sorted dimensions
     """
     return 'p' + 'x'.join(str(dim) for dim in sorted(mapShape)) + '.foldsTotal'
 
@@ -76,10 +83,15 @@ def getPathFilenameFoldsTotal(mapShape: Union[Sequence[int], numpy.ndarray[Tuple
     Returns:
         pathlib.Path: Complete path to the folds total file.
     """
-    pathFilenameFoldsTotal = pathlib.Path(pathLikeWriteFoldsTotal) if pathLikeWriteFoldsTotal is not None else getPathJobDEFAULT()
+    pathFilenameFoldsTotal = pathlib.Path(pathLikeWriteFoldsTotal) if pathLikeWriteFoldsTotal is not None else getPathJobRootDEFAULT()
     if pathFilenameFoldsTotal.is_dir():
         filenameFoldsTotalDEFAULT = getFilenameFoldsTotal(mapShape)
         pathFilenameFoldsTotal = pathFilenameFoldsTotal / filenameFoldsTotalDEFAULT
+    elif pathlib.Path(pathLikeWriteFoldsTotal).is_absolute(): # type: ignore
+        pathFilenameFoldsTotal = pathlib.Path(pathLikeWriteFoldsTotal) # type: ignore
+    else:
+        pathFilenameFoldsTotal = pathlib.Path(getPathJobRootDEFAULT(), pathLikeWriteFoldsTotal) # type: ignore
+
     pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
     return pathFilenameFoldsTotal
 

{mapfolding-0.3.9 → mapfolding-0.3.11}/mapFolding/oeis.py

@@ -1,8 +1,8 @@
 """Everything implementing the The Online Encyclopedia of Integer Sequences (OEIS);
 _only_ things that implement _only_ the OEIS."""
 from datetime import datetime, timedelta
-from mapFolding import countFolds
-from typing import TYPE_CHECKING, List, Callable, Dict, Final, Union, Any
+from mapFolding import countFolds, getPathPackage
+from typing import Any, Callable, Dict, Final, List, Tuple, TYPE_CHECKING, Union
 import argparse
 import pathlib
 import random
@@ -10,6 +10,7 @@ import sys
 import time
 import urllib.request
 import urllib.response
+import warnings
 
 if TYPE_CHECKING:
     from typing import TypedDict
@@ -18,10 +19,12 @@ else:
 
 """
 Section: make `settingsOEIS`"""
+
+_pathCache = getPathPackage() / ".cache"
+
 class SettingsOEIS(TypedDict):
-    # I would prefer to load description dynamically from OEIS, but it's a pita for me
-    # to learn how to efficiently implement right now.
     description: str
+    offset: int
     getMapShape: Callable[[int], List[int]]
     valuesBenchmark: List[int]
     valuesKnown: Dict[int, int]
@@ -31,40 +34,33 @@ class SettingsOEIS(TypedDict):
 
 settingsOEIShardcodedValues: Dict[str, Dict[str, Any]] = {
     'A001415': {
-        'description': 'Number of ways of folding a 2 X n strip of stamps.',
         'getMapShape': lambda n: sorted([2, n]),
         'valuesBenchmark': [14],
         'valuesTestParallelization': [*range(3, 7)],
         'valuesTestValidation': [0, 1, random.randint(2, 9)],
     },
     'A001416': {
-        'description': 'Number of ways of folding a 3 X n strip of stamps.',
         'getMapShape': lambda n: sorted([3, n]),
         'valuesBenchmark': [9],
         'valuesTestParallelization': [*range(3, 5)],
         'valuesTestValidation': [0, 1, random.randint(2, 6)],
     },
     'A001417': {
-        'description': 'Number of ways of folding a 2 X 2 X ... X 2 n-dimensional map.',
         'getMapShape': lambda n: [2] * n,
         'valuesBenchmark': [6],
         'valuesTestParallelization': [*range(2, 4)],
         'valuesTestValidation': [0, 1, random.randint(2, 4)],
     },
     'A195646': {
-        'description': 'Number of ways of folding a 3 X 3 X ... X 3 n-dimensional map.',
         'getMapShape': lambda n: [3] * n,
         'valuesBenchmark': [3],
         'valuesTestParallelization': [*range(2, 3)],
         'valuesTestValidation': [0, 1, 2],
     },
     'A001418': {
-        'description': 'Number of ways of folding an n X n sheet of stamps.',
         'getMapShape': lambda n: [n, n],
         'valuesBenchmark': [5],
         'valuesTestParallelization': [*range(2, 4)],
-        # offset 1: hypothetically, if I were to load the offset from OEIS, I could use it to
-        # determine if a sequence is defined at n=0, which would affect, for example, the valuesTestValidation.
         'valuesTestValidation': [1, random.randint(2, 4)],
     },
 }
@@ -125,9 +121,9 @@ def _parseBFileOEIS(OEISbFile: str, oeisID: str) -> Dict[int, int]:
         sequence ID or if the content format is invalid.
     """
     bFileLines = OEISbFile.strip().splitlines()
-    # The first line has the sequence ID
     if not bFileLines.pop(0).startswith(f"# {oeisID}"):
-        raise ValueError(f"Content does not match sequence {oeisID}")
+        warnings.warn(f"Content does not match sequence {oeisID}")
+        return {-1: -1}
 
     OEISsequence = {}
     for line in bFileLines:
@@ -137,10 +133,30 @@ def _parseBFileOEIS(OEISbFile: str, oeisID: str) -> Dict[int, int]:
         OEISsequence[n] = aOFn
     return OEISsequence
 
-try:
-    _pathCache = pathlib.Path(__file__).parent / ".cache"
-except NameError:
-    _pathCache = pathlib.Path.home() / ".mapFoldingCache"
+def _getOEISofficial(pathFilenameCache: pathlib.Path, url: str) -> None | str:
+    cacheDays = 7
+    tryCache = False
+    if pathFilenameCache.exists():
+        fileAge = datetime.now() - datetime.fromtimestamp(pathFilenameCache.stat().st_mtime)
+        tryCache = fileAge < timedelta(days=cacheDays)
+
+    oeisInformation = None
+    if tryCache:
+        try:
+            oeisInformation = pathFilenameCache.read_text()
+        except IOError:
+            tryCache = False
+
+    if not tryCache:
+        httpResponse: urllib.response.addinfourl = urllib.request.urlopen(url)
+        oeisInformation = httpResponse.read().decode('utf-8')
+        pathFilenameCache.parent.mkdir(parents=True, exist_ok=True)
+        pathFilenameCache.write_text(oeisInformation)
+
+    if not oeisInformation:
+        warnings.warn(f"Failed to retrieve OEIS sequence information for {pathFilenameCache.stem}.")
+
+    return oeisInformation
 
 def _getOEISidValues(oeisID: str) -> Dict[int, int]:
     """
@@ -162,64 +178,60 @@ def _getOEISidValues(oeisID: str) -> Dict[int, int]:
     """
 
     pathFilenameCache = _pathCache / _getFilenameOEISbFile(oeisID)
-    cacheDays = 7
+    url = f"https://oeis.org/{oeisID}/{_getFilenameOEISbFile(oeisID)}"
 
-    tryCache = False
-    if pathFilenameCache.exists():
-        fileAge = datetime.now() - datetime.fromtimestamp(pathFilenameCache.stat().st_mtime)
-        tryCache = fileAge < timedelta(days=cacheDays)
+    oeisInformation = _getOEISofficial(pathFilenameCache, url)
 
-    if tryCache:
-        try:
-            OEISbFile = pathFilenameCache.read_text()
-            return _parseBFileOEIS(OEISbFile, oeisID)
-        except (ValueError, IOError):
-            tryCache = False
-
-    urlOEISbFile = f"https://oeis.org/{oeisID}/{_getFilenameOEISbFile(oeisID)}"
-    httpResponse: urllib.response.addinfourl = urllib.request.urlopen(urlOEISbFile)
-    OEISbFile = httpResponse.read().decode('utf-8')
-
-    if not tryCache:
-        pathFilenameCache.parent.mkdir(parents=True, exist_ok=True)
-        pathFilenameCache.write_text(OEISbFile)
+    if oeisInformation:
+        return _parseBFileOEIS(oeisInformation, oeisID)
+    return {-1: -1}
 
-    return _parseBFileOEIS(OEISbFile, oeisID)
+def _getOEISidInformation(oeisID: str) -> Tuple[str, int]:
+    oeisID = _validateOEISid(oeisID)
+    pathFilenameCache = _pathCache / f"{oeisID}.txt"
+    url = f"https://oeis.org/search?q=id:{oeisID}&fmt=text"
+
+    oeisInformation = _getOEISofficial(pathFilenameCache, url)
+
+    if not oeisInformation:
+        return "Not found", -1
+
+    description_parts = []
+    offset = None
+    for line in oeisInformation.splitlines():
+        if line.startswith('%N'):
+            parts = line.split()
+            if parts[1] == oeisID:
+                desc_part = ' '.join(parts[2:])
+                description_parts.append(desc_part)
+        elif line.startswith('%O'):
+            parts = line.split()
+            if parts[1] == oeisID:
+                offset_str = parts[2].split(',')[0]
+                offset = int(offset_str)
+    if not description_parts:
+        warnings.warn(f"No description found for {oeisID}")
+        description_parts.append("No description found")
+    if offset is None:
+        warnings.warn(f"No offset found for {oeisID}")
+        offset = -1
+    description = ' '.join(description_parts)
+    return description, offset
 
 def makeSettingsOEIS() -> Dict[str, SettingsOEIS]:
-    """
-    Creates a dictionary mapping OEIS IDs to their corresponding settings.
-
-    This function initializes settings for each implemented OEIS sequence by combining
-    hardcoded values with dynamically retrieved OEIS sequence values.
-
-    Returns:
-        Dict[str, SettingsOEIS]: A dictionary where:
-            - Keys are OEIS sequence IDs (str)
-            - Values are SettingsOEIS objects containing:
-                - description: Text description of the sequence
-                - getMapShape: Function to get dimensions
-                - valuesBenchmark: Benchmark values
-                - valuesKnown: Known values from OEIS
-                - valuesTestValidation: Values for test validation
-                - valueUnknown: First unknown value in sequence
-
-    Note:
-        Relies on global variables:
-        - oeisIDsImplemented: List of implemented OEIS sequence IDs
-        - settingsOEIShardcodedValues: Dictionary of hardcoded settings per sequence
-    """
     settingsTarget = {}
     for oeisID in oeisIDsImplemented:
         valuesKnownSherpa = _getOEISidValues(oeisID)
+        descriptionSherpa, offsetSherpa = _getOEISidInformation(oeisID)
         settingsTarget[oeisID] = SettingsOEIS(
-            description=settingsOEIShardcodedValues[oeisID]['description'],
+            description=descriptionSherpa,
+            offset=offsetSherpa,
             getMapShape=settingsOEIShardcodedValues[oeisID]['getMapShape'],
             valuesBenchmark=settingsOEIShardcodedValues[oeisID]['valuesBenchmark'],
             valuesTestParallelization=settingsOEIShardcodedValues[oeisID]['valuesTestParallelization'],
             valuesTestValidation=settingsOEIShardcodedValues[oeisID]['valuesTestValidation'],
-            valuesKnown = valuesKnownSherpa,
-            valueUnknown = max(valuesKnownSherpa.keys(), default=0) + 1
+            valuesKnown=valuesKnownSherpa,
+            valueUnknown=max(valuesKnownSherpa.keys(), default=0) + 1
         )
     return settingsTarget
 
@@ -278,11 +290,11 @@ def oeisIDfor_n(oeisID: str, n: int) -> int:
     listDimensions = settingsOEIS[oeisID]['getMapShape'](n)
 
     if n <= 1 or len(listDimensions) < 2:
-        foldsTotal = settingsOEIS[oeisID]['valuesKnown'].get(n, None)
-        if foldsTotal is not None:
-            return foldsTotal
-        else:
+        offset = settingsOEIS[oeisID]['offset']
+        if n < offset:
             raise ArithmeticError(f"OEIS sequence {oeisID} is not defined at n={n}.")
+        foldsTotal = settingsOEIS[oeisID]['valuesKnown'][n]
+        return foldsTotal
 
     return countFolds(listDimensions)
 
@@ -314,11 +326,9 @@ def clearOEIScache() -> None:
     if not _pathCache.exists():
         print(f"Cache directory, {_pathCache}, not found - nothing to clear.")
         return
-    else:
-        for oeisID in settingsOEIS:
-            pathFilenameCache = _pathCache / _getFilenameOEISbFile(oeisID)
-            pathFilenameCache.unlink(missing_ok=True)
-
+    for oeisID in settingsOEIS:
+        ( _pathCache / f"{oeisID}.txt" ).unlink(missing_ok=True)
+        ( _pathCache / _getFilenameOEISbFile(oeisID) ).unlink(missing_ok=True)
     print(f"Cache cleared from {_pathCache}")
 
 def getOEISids() -> None:

{mapfolding-0.3.9 → mapfolding-0.3.11}/mapFolding/someAssemblyRequired/makeJob.py

@@ -1,6 +1,6 @@
-import importlib.util
 from mapFolding import getPathFilenameFoldsTotal, computationState, outfitCountFolds, getAlgorithmSource
-from typing import Any, Literal, Optional, Sequence, Type, overload
+from types import ModuleType
+from typing import Any, Literal, Optional, Sequence, overload
 import pathlib
 import pickle
 
@@ -14,7 +14,7 @@ def makeStateJob(listDimensions: Sequence[int], *, writeJob: Literal[False]
                  , **keywordArguments: Optional[str]) -> computationState:
     ...
 
-def makeStateJob(listDimensions: Sequence[int], *, writeJob: bool = True, **keywordArguments: Optional[str]) -> computationState | pathlib.Path:
+def makeStateJob(listDimensions: Sequence[int], *, writeJob: bool = True, **keywordArguments: Optional[Any]) -> computationState | pathlib.Path:
     """
     Creates a computation state job for map folding calculations and optionally saves it to disk.
 
@@ -43,10 +43,9 @@ def makeStateJob(listDimensions: Sequence[int], *, writeJob: bool = True, **keyw
     when writeJob is True. The file is saved in a directory structure based on the map shape.
     """
 
-    stateUniversal: computationState = outfitCountFolds(listDimensions, computationDivisions=None, CPUlimit=None, **keywordArguments)
+    stateUniversal: computationState = outfitCountFolds(listDimensions, **keywordArguments)
 
-
-    moduleSource = getAlgorithmSource()
+    moduleSource: ModuleType = getAlgorithmSource()
     moduleSource.countInitialize(stateUniversal['connectionGraph'], stateUniversal['gapsWhere'], stateUniversal['my'], stateUniversal['track'])
 
     if not writeJob:

{mapfolding-0.3.9 → mapfolding-0.3.11}/mapFolding/someAssemblyRequired/synthesizeModuleJAX.py

@@ -1,4 +1,4 @@
-from mapFolding import getAlgorithmSource, relativePathSyntheticModules
+from mapFolding import getAlgorithmSource, getPathSyntheticModules
 from mapFolding import setDatatypeModule, setDatatypeFoldsTotal, setDatatypeElephino, setDatatypeLeavesTotal
 from typing import Optional
 import ast
@@ -18,7 +18,7 @@ def writeJax(*, codeSource: Optional[str] = None, pathFilenameAlgorithm: Optiona
     else:
         raise NotImplementedError("You haven't written this part yet.")
     if pathFilenameDestination is None:
-        pathFilenameDestination = pathFilenameAlgorithm.parent / relativePathSyntheticModules / "countJax.py"
+        pathFilenameDestination = getPathSyntheticModules() / "countJax.py"
     # pathFilenameDestination.write_text(transformedText)
 
 if __name__ == '__main__':