mapFolding 0.2.6__py3-none-any.whl → 0.3.0__py3-none-any.whl

mapFolding/oeis.py

@@ -1,323 +0,0 @@
-"""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
-import pathlib
-import random
-import sys
-import time
-import urllib.request
-import urllib.response
-
-if TYPE_CHECKING:
-    from typing import TypedDict
-else:
-    TypedDict = dict
-
-"""
-Section: make `settingsOEIS`"""
-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
-    getDimensions: Callable[[int], List[int]]
-    valuesBenchmark: List[int]
-    valuesKnown: Dict[int, int]
-    valuesTestValidation: List[int]
-    valueUnknown: int
-
-settingsOEIShardcodedValues = {
-    'A001415': {
-        'description': 'Number of ways of folding a 2 X n strip of stamps.',
-        'getDimensions': lambda n: sorted([2, n]),
-        'valuesBenchmark': [14],
-        'valuesTestValidation': [0, 1, random.randint(2, 9)],
-    },
-    'A001416': {
-        'description': 'Number of ways of folding a 3 X n strip of stamps.',
-        'getDimensions': lambda n: sorted([3, n]),
-        'valuesBenchmark': [9],
-        'valuesTestValidation': [0, 1, random.randint(2, 6)],
-    },
-    'A001417': {
-        'description': 'Number of ways of folding a 2 X 2 X ... X 2 n-dimensional map.',
-        'getDimensions': lambda n: [2] * n,
-        'valuesBenchmark': [6],
-        'valuesTestValidation': [0, 1, random.randint(2, 4)],
-    },
-    'A195646': {
-        'description': 'Number of ways of folding a 3 X 3 X ... X 3 n-dimensional map.',
-        'getDimensions': lambda n: [3] * n,
-        'valuesBenchmark': [3],
-        'valuesTestValidation': [0, 1, 2],
-    },
-    'A001418': {
-        'description': 'Number of ways of folding an n X n sheet of stamps.',
-        'getDimensions': lambda n: [n, n],
-        'valuesBenchmark': [5],
-        # 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)],
-    },
-}
-
-oeisIDsImplemented: Final[List[str]]  = sorted([oeisID.upper().strip() for oeisID in settingsOEIShardcodedValues.keys()])
-"""Directly implemented OEIS IDs; standardized, e.g., 'A001415'."""
-
-def _validateOEISid(oeisIDcandidate: str):
-    """
-    Validates an OEIS sequence ID against implemented sequences.
-
-    If the provided ID is recognized within the application's implemented
-    OEIS sequences, the function returns the verified ID in uppercase.
-    Otherwise, a KeyError is raised indicating that the sequence is not
-    directly supported.
-
-    Parameters:
-        oeisIDcandidate: The OEIS sequence identifier to validate.
-
-    Returns:
-        oeisID: The validated and possibly modified OEIS sequence ID, if recognized.
-
-    Raises:
-        KeyError: If the provided sequence ID is not directly implemented.
-    """
-    if oeisIDcandidate in oeisIDsImplemented:
-        return oeisIDcandidate
-    else:
-        oeisIDcleaned = str(oeisIDcandidate).upper().strip()
-        if oeisIDcleaned in oeisIDsImplemented:
-            return oeisIDcleaned
-        else:
-            raise KeyError(
-                f"OEIS ID {oeisIDcandidate} is not directly implemented.\n"
-                f"Available sequences:\n{_formatOEISsequenceInfo()}"
-            )
-
-def _getFilenameOEISbFile(oeisID: str) -> str:
-    oeisID = _validateOEISid(oeisID)
-    return f"b{oeisID[1:]}.txt"
-
-def _parseBFileOEIS(OEISbFile: str, oeisID: str) -> Dict[int, int]:
-    """
-    Parses the content of an OEIS b-file for a given sequence ID.
-    This function processes a multiline string representing an OEIS b-file and
-    creates a dictionary mapping integer indices to their corresponding sequence
-    values. The first line of the b-file is expected to contain a comment that
-    matches the given sequence ID. If it does not match, a ValueError is raised.
-
-    Parameters:
-        OEISbFile: A multiline string representing an OEIS b-file.
-        oeisID: The expected OEIS sequence identifier.
-    Returns:
-        OEISsequence: A dictionary where each key is an integer index `n` and
-        each value is the sequence value `a(n)` corresponding to that index.
-    Raises:
-        ValueError: If the first line of the file does not indicate the expected
-        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}")
-
-    OEISsequence = {}
-    for line in bFileLines:
-        if line.startswith('#'):
-            continue
-        n, aOFn = map(int, line.split())
-        OEISsequence[n] = aOFn
-    return OEISsequence
-
-try:
-    _pathCache = pathlib.Path(__file__).parent / ".cache"
-except NameError:
-    _pathCache = pathlib.Path.home() / ".mapFoldingCache"
-
-def _getOEISidValues(oeisID: str) -> Dict[int, int]:
-    """
-    Retrieves the specified OEIS sequence as a dictionary mapping integer indices
-    to their corresponding values.
-    This function checks for a cached local copy of the sequence data, using it if
-    it has not expired. Otherwise, it fetches the sequence data from the OEIS
-    website and writes it to the cache. The parsed data is returned as a dictionary
-    mapping each index to its sequence value.
-
-    Parameters:
-        oeisID: The identifier of the OEIS sequence to retrieve.
-    Returns:
-        OEISsequence: A dictionary where each key is an integer index, `n`, and each
-        value is the corresponding "a(n)" from the OEIS entry.
-    Raises:
-        ValueError: If the cached or downloaded file format is invalid.
-        IOError: If there is an error reading from or writing to the local cache.
-    """
-
-    pathFilenameCache = _pathCache / _getFilenameOEISbFile(oeisID)
-    cacheDays = 7
-
-    tryCache = False
-    if pathFilenameCache.exists():
-        fileAge = datetime.now() - datetime.fromtimestamp(pathFilenameCache.stat().st_mtime)
-        tryCache = fileAge < timedelta(days=cacheDays)
-
-    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)
-
-    return _parseBFileOEIS(OEISbFile, oeisID)
-
-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
-                - getDimensions: 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)
-        settingsTarget[oeisID] = SettingsOEIS(
-            description = settingsOEIShardcodedValues[oeisID]['description'],
-            getDimensions = settingsOEIShardcodedValues[oeisID]['getDimensions'],
-            valuesBenchmark = settingsOEIShardcodedValues[oeisID]['valuesBenchmark'],
-            valuesKnown = valuesKnownSherpa,
-            valuesTestValidation = settingsOEIShardcodedValues[oeisID]['valuesTestValidation'],
-            valueUnknown = max(valuesKnownSherpa.keys(), default=0) + 1
-        )
-    return settingsTarget
-
-settingsOEIS: Dict[str, SettingsOEIS] = makeSettingsOEIS()
-"""All values and settings for `oeisIDsImplemented`."""
-
-"""
-Section: private functions"""
-
-def _formatHelpText() -> str:
-    """Format standardized help text for both CLI and interactive use."""
-    exampleOEISid = oeisIDsImplemented[0]
-    exampleN = settingsOEIS[exampleOEISid]['valuesTestValidation'][-1]
-
-    return (
-        "\nAvailable OEIS sequences:\n"
-        f"{_formatOEISsequenceInfo()}\n"
-        "\nUsage examples:\n"
-        "  Command line:\n"
-        f"    OEIS_for_n {exampleOEISid} {exampleN}\n"
-        "  Python:\n"
-        "    from mapFolding import oeisIDfor_n\n"
-        f"    foldsTotal = oeisIDfor_n('{exampleOEISid}', {exampleN})"
-    )
-
-def _formatOEISsequenceInfo() -> str:
-    """Format information about available OEIS sequences for display or error messages."""
-    return "\n".join(
-        f"  {oeisID}: {settingsOEIS[oeisID]['description']}"
-        for oeisID in oeisIDsImplemented
-    )
-
-"""
-Section: public functions"""
-
-def oeisIDfor_n(oeisID: str, n: int) -> int:
-    """
-    Calculate a(n) of a sequence from "The On-Line Encyclopedia of Integer Sequences" (OEIS).
-
-    Parameters:
-        oeisID: The ID of the OEIS sequence.
-        n: A non-negative integer for which to calculate the sequence value.
-
-    Returns:
-        sequenceValue: a(n) of the OEIS sequence.
-
-    Raises:
-        ValueError: If n is negative.
-        KeyError: If the OEIS sequence ID is not directly implemented.
-    """
-    oeisID = _validateOEISid(oeisID)
-
-    if not isinstance(n, int) or n < 0:
-        raise ValueError("`n` must be non-negative integer.")
-
-    listDimensions = settingsOEIS[oeisID]['getDimensions'](n)
-
-    if n <= 1 or len(listDimensions) < 2:
-        foldsTotal = settingsOEIS[oeisID]['valuesKnown'].get(n, None)
-        if foldsTotal is not None:
-            return foldsTotal
-        else:
-            raise ArithmeticError(f"OEIS sequence {oeisID} is not defined at n={n}.")
-
-    return countFolds(listDimensions)
-
-def OEIS_for_n() -> None:
-    """Command-line interface for oeisIDfor_n."""
-    import argparse
-
-    parserCLI = argparse.ArgumentParser(
-        description="Calculate a(n) for an OEIS sequence.",
-        epilog=_formatHelpText(),
-        formatter_class=argparse.RawDescriptionHelpFormatter
-    )
-    parserCLI.add_argument('oeisID', help="OEIS sequence identifier")
-    parserCLI.add_argument('n', type=int, help="Calculate a(n) for this n")
-
-    argumentsCLI = parserCLI.parse_args()
-
-    timeStart = time.perf_counter()
-
-    try:
-        print(oeisIDfor_n(argumentsCLI.oeisID, argumentsCLI.n), "distinct folding patterns.")
-    except (KeyError, ValueError, ArithmeticError) as ERRORmessage:
-        print(f"Error: {ERRORmessage}", file=sys.stderr)
-        sys.exit(1)
-
-    timeElapsed = time.perf_counter() - timeStart
-    print(f"Time elapsed: {timeElapsed:.3f} seconds")
-
-def clearOEIScache() -> None:
-    """Delete all cached OEIS sequence files."""
-    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)
-
-    print(f"Cache cleared from {_pathCache}")
-
-def getOEISids() -> None:
-    """Print all available OEIS sequence IDs that are directly implemented."""
-    print(_formatHelpText())
-
-if __name__ == "__main__":
-    getOEISids()

mapFolding/someAssemblyRequired/jobsAndTasks.py

@@ -1,47 +0,0 @@
-from typing import Any, Optional, Sequence, Type, Union
-
-def Z0Z_makeJob(listDimensions: Sequence[int], **keywordArguments: Optional[Type[Any]]):
-    from mapFolding import outfitCountFolds
-    stateUniversal = outfitCountFolds(listDimensions, computationDivisions=None, CPUlimit=None, **keywordArguments)
-    from mapFolding.someAssemblyRequired.countInitializeNoNumba import countInitialize
-    countInitialize(stateUniversal['connectionGraph'], stateUniversal['gapsWhere'], stateUniversal['my'], stateUniversal['the'], stateUniversal['track'])
-    from mapFolding import getPathFilenameFoldsTotal
-    pathFilenameChopChop = getPathFilenameFoldsTotal(stateUniversal['mapShape'])
-    import pathlib
-    suffix = pathFilenameChopChop.suffix
-    pathJob = pathlib.Path(str(pathFilenameChopChop)[0:-len(suffix)])
-    pathJob.mkdir(parents=True, exist_ok=True)
-    pathFilenameJob = pathJob / 'stateJob.pkl'
-
-    pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateUniversal['mapShape'], pathFilenameJob.parent)
-    stateJob = {**stateUniversal, 'pathFilenameFoldsTotal': pathFilenameFoldsTotal}
-
-    del stateJob['mapShape']
-
-    import pickle
-    pathFilenameJob.write_bytes(pickle.dumps(stateJob))
-    return pathFilenameJob
-
-def runJob(pathFilename):
-    from typing import Final
-    import numpy
-    from pathlib import Path
-    pathFilenameJob = Path(pathFilename)
-    from pickle import loads
-    stateJob = loads(pathFilenameJob.read_bytes())
-
-    connectionGraph: numpy.ndarray = stateJob['connectionGraph']
-    foldsSubTotals: numpy.ndarray = stateJob['foldsSubTotals']
-    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.someAssemblyRequired.countSequentialNoNumba import countSequential
-    countSequential(connectionGraph, foldsSubTotals, gapsWhere, my, the, track)
-
-    print(foldsSubTotals.sum().item())
-    Path(pathFilenameFoldsTotal).parent.mkdir(parents=True, exist_ok=True)
-    Path(pathFilenameFoldsTotal).write_text(str(foldsSubTotals.sum().item()))
-    print(pathFilenameFoldsTotal)

mapFolding/someAssemblyRequired/makeNuitkaSource.py

@@ -1,99 +0,0 @@
-"""NOTE make a special venv for nuitka, then run nuitka from that venv"""
-from pathlib import Path
-from pickle import loads
-from typing import Final
-import numpy
-from mapFolding.someAssemblyRequired.jobsAndTasks import Z0Z_makeJob
-
-"""
-Section: configure every time"""
-
-# TODO configure this
-mapShape = [3]*3
-# NOTE ^^^^^^ pay attention
-
-"""
-Section: settings"""
-
-pathFilenameData = Z0Z_makeJob(mapShape)
-
-pathJob = pathFilenameData.parent
-
-pathFilenameAlgorithm = Path('/apps/mapFolding/mapFolding/countSequentialNoNumba.py')
-pathFilenameDestination = Path(f"/apps/mapFolding/nn/{pathJob.name}.py")
-
-"""
-Section: did you handle and include this stuff?"""
-
-lineImportNumPy = "import numpy"
-linePrintFoldsTotal = "print(foldsSubTotals.sum().item())"
-linesAlgorithm = """"""
-linesData = """"""
-settingsNuitkaProject=f"""
-# nuitka-project: --mode=onefile
-# nuitka-project: --onefile-no-compression
-# nuitka-project: --lto=yes
-# nuitka-project: --clang
-# nuitka-project: --output-dir={pathJob}
-# nuitka-project: --output-filename={pathJob.name}.exe
-"""
-# nuitka-project:
-"""
-Section: do the work"""
-
-WTFamIdoing = pathFilenameAlgorithm.read_text()
-for lineSource in WTFamIdoing.splitlines():
-    ImaIndent = '    '
-    if lineSource.startswith(ImaIndent):
-        lineSource = lineSource[len(ImaIndent):None]
-    elif lineSource.startswith('#'):
-        continue
-    elif not lineSource:
-        continue
-    elif lineSource.startswith('def '):
-        continue
-    else:
-        raise NotImplementedError("You didn't anticipate this.")
-    linesAlgorithm = "\n".join([linesAlgorithm
-                            , lineSource
-                            ])
-
-stateJob = loads(pathFilenameData.read_bytes())
-connectionGraph: Final[numpy.ndarray] = stateJob['connectionGraph']
-foldsSubTotals: numpy.ndarray = stateJob['foldsSubTotals']
-gapsWhere: numpy.ndarray = stateJob['gapsWhere']
-my: numpy.ndarray = stateJob['my']
-the: numpy.ndarray = stateJob['the']
-track: numpy.ndarray = stateJob['track']
-
-pathFilenameFoldsTotal = stateJob['pathFilenameFoldsTotal']
-lineDataPathFilenameFoldsTotal = "pathFilenameFoldsTotal = r'" + str(pathFilenameFoldsTotal) + "'\n"
-
-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=100,
-        separator=','
-        )
-    return f"{identifierName} = numpy.array({arrayAsTypeStr}, dtype=numpy.{arrayTarget.dtype})\n"
-
-linesData = "\n".join([linesData
-            , lineDataPathFilenameFoldsTotal
-            , archivistFormatsArrayToCode(the, 'the')
-            , archivistFormatsArrayToCode(my, 'my')
-            , archivistFormatsArrayToCode(foldsSubTotals, 'foldsSubTotals')
-            , archivistFormatsArrayToCode(gapsWhere, 'gapsWhere')
-            , archivistFormatsArrayToCode(connectionGraph, 'connectionGraph')
-            , archivistFormatsArrayToCode(track, 'track')
-            ])
-
-linesAll = "\n".join([settingsNuitkaProject
-            , lineImportNumPy
-            , linesData
-            , linesAlgorithm
-            , linePrintFoldsTotal
-            ])
-
-pathFilenameDestination.write_text(linesAll)

mapFolding/someAssemblyRequired/makeNumbaJob.py

@@ -1,144 +0,0 @@
-"""Create a python module hardcoded to compute a map's foldsTotal.
-- NumPy ndarray.
-- Numba optimized.
-- Absolutely no other imports.
-
-Can create LLVM IR from the module: of unknown utility.
-"""
-# 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
-import llvmlite.binding
-import numpy
-import pathlib
-import pickle
-import python_minifier
-
-listDimensions = [6,6]
-
-# NOTE this overwrites files
-Z0Z_inlineMapFolding()
-
-identifierCallableLaunch = "goGoGadgetAbsurdity"
-
-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
-    datatypeDefault = 'uint8'
-    numpy_dtypeDefault = make_dtype(datatypeDefault)
-    numpy_dtypeSmall = numpy_dtypeDefault
-
-    parametersNumba = f"numba.types.{datatypeLarge}(), \
-cache=True, \
-"
-# no_cfunc_wrapper=True, \
-# no_cpython_wrapper=True, \
-# _nrt=True, \
-# nopython=True, \
-# parallel=False, \
-# boundscheck=False, \
-# error_model='numpy', \
-# fastmath=True, \
-# no_cfunc_wrapper=False, \
-# no_cpython_wrapper=False, \
-# looplift=True, \
-# forceinline=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})"
-
-    linesImport = "\n".join([
-                        "import numpy"
-                        , "import numba"
-                        ])
-
-    stateJob = pickle.loads(pathFilenameData.read_bytes())
-
-    ImaIndent = '    '
-    linesDataDynamic = """"""
-    linesDataDynamic = "\n".join([linesDataDynamic
-            , ImaIndent + f"foldsTotal = numba.types.{datatypeLarge}(0)"
-            , ImaIndent + convertNDArrayToStr(stateJob['my'], 'my')
-            , ImaIndent + convertNDArrayToStr(stateJob['foldsSubTotals'], 'foldsSubTotals')
-            , ImaIndent + convertNDArrayToStr(stateJob['gapsWhere'], 'gapsWhere')
-            , ImaIndent + convertNDArrayToStr(stateJob['track'], 'track')
-            ])
-
-    linesDataStatic = """"""
-    linesDataStatic = "\n".join([linesDataStatic
-            , ImaIndent + convertNDArrayToStr(stateJob['the'], 'the')
-            , ImaIndent + convertNDArrayToStr(stateJob['connectionGraph'], 'connectionGraph')
-            ])
-
-    pathFilenameFoldsTotal: pathlib.Path = stateJob['pathFilenameFoldsTotal']
-
-    linesAlgorithm = """"""
-    for lineSource in pathFilenameAlgorithm.read_text().splitlines():
-        if lineSource.startswith('#'):
-            continue
-        elif not lineSource:
-            continue
-        elif lineSource.startswith('def '):
-            lineSource = "\n".join([lineNumba
-                                , f"def {identifierCallableLaunch}():"
-                                , linesDataDynamic
-                                , linesDataStatic
-                                ])
-        linesAlgorithm = "\n".join([linesAlgorithm
-                            , lineSource
-                            ])
-
-    linesLaunch = """"""
-    linesLaunch = linesLaunch + f"""
-if __name__ == '__main__':
-    {identifierCallableLaunch}()"""
-
-    linesWriteFoldsTotal = """"""
-    linesWriteFoldsTotal = "\n".join([linesWriteFoldsTotal
-                                    , "    foldsTotal = foldsSubTotals.sum().item()"
-                                    , "    print(foldsTotal)"
-                                    , "    with numba.objmode():"
-                                    , f"        open('{pathFilenameFoldsTotal.as_posix()}', 'w').write(str(foldsTotal))"
-                                    , "    return foldsTotal"
-                                    ])
-
-    linesAll = "\n".join([
-                        linesImport
-                        , linesAlgorithm
-                        , linesWriteFoldsTotal
-                        , linesLaunch
-                        ])
-
-    pathFilenameDestination.write_text(linesAll)
-
-    return pathFilenameDestination
-
-def writeModuleLLVM(pathFilenamePythonFile: pathlib.Path) -> pathlib.Path:
-    pathRootPackage = pathlib.Path('c:/apps/mapFolding')
-    relativePathModule = pathFilenamePythonFile.relative_to(pathRootPackage)
-    moduleTarget = '.'.join(relativePathModule.parts)[0:-len(relativePathModule.suffix)]
-    moduleTargetImported = importlib.import_module(moduleTarget)
-    linesLLVM = moduleTargetImported.__dict__[identifierCallableLaunch].inspect_llvm()[()]
-    moduleLLVM = llvmlite.binding.module.parse_assembly(linesLLVM)
-    pathFilenameLLVM = pathFilenamePythonFile.with_suffix(".ll")
-    pathFilenameLLVM.write_text(str(moduleLLVM))
-    return pathFilenameLLVM
-
-if __name__ == '__main__':
-    pathFilenamePythonFile = writeModuleWithNumba(listDimensions)
-    pathFilenameLLVM = writeModuleLLVM(pathFilenamePythonFile)

mapFolding/startHere.py

@@ -1,50 +0,0 @@
-from mapFolding import outfitCountFolds, getPathFilenameFoldsTotal, saveFoldsTotal
-from typing import Any, Optional, Sequence, Type, Union
-import os
-
-def countFolds(listDimensions: Sequence[int], pathishWriteFoldsTotal: Optional[Union[str, os.PathLike[str]]] = None, computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[int, float, bool]] = None, **keywordArguments: Optional[Type[Any]]) -> int:
-    """Count the total number of possible foldings for a given map dimensions.
-
-    Parameters:
-        listDimensions: List of integers representing the dimensions of the map to be folded.
-        pathishWriteFoldsTotal (None): Path, filename, or pathFilename to write the total fold count to.
-            If a directory is provided, creates a file with a default name based on map dimensions.
-        computationDivisions (None):
-            Whether and how to divide the computational work. See notes for details.
-        CPUlimit (None): This is only relevant if there are `computationDivisions`: whether and how to limit the CPU usage. See notes for details.
-        **keywordArguments: Additional arguments including `dtypeDefault` and `dtypeLarge` for data type specifications.
-    Returns:
-        foldsSubTotals: Total number of distinct ways to fold a map of the given dimensions.
-
-    Computation divisions:
-        - None: no division of the computation into tasks; sets task divisions to 0
-        - int: direct set the number of task divisions; cannot exceed the map's total leaves
-        - "maximum": divides into `leavesTotal`-many `taskDivisions`
-        - "cpu": limits the divisions to the number of available CPUs, i.e. `concurrencyLimit`
-
-    Limits on CPU usage `CPUlimit`:
-        - `False`, `None`, or `0`: No limits on CPU usage; uses all available CPUs. All other values will potentially limit CPU usage.
-        - `True`: Yes, limit the CPU usage; limits to 1 CPU.
-        - Integer `>= 1`: Limits usage to the specified number of CPUs.
-        - Decimal value (`float`) between 0 and 1: Fraction of total CPUs to use.
-        - Decimal value (`float`) between -1 and 0: Fraction of CPUs to *not* use.
-        - Integer `<= -1`: Subtract the absolute value from total CPUs.
-
-    N.B.: You probably don't want to divide the computation into tasks.
-        If you want to compute a large `foldsTotal`, dividing the computation into tasks is usually a bad idea. Dividing the algorithm into tasks is inherently inefficient: efficient division into tasks means there would be no overlap in the work performed by each task. When dividing this algorithm, the amount of overlap is between 50% and 90% by all tasks: at least 50% of the work done by every task must be done by _all_ tasks. If you improve the computation time, it will only change by -10 to -50% depending on (at the very least) the ratio of the map dimensions and the number of leaves. If an undivided computation would take 10 hours on your computer, for example, the computation will still take at least 5 hours but you might reduce the time to 9 hours. Most of the time, however, you will increase the computation time. If logicalCores >= leavesTotal, it will probably be faster. If logicalCores <= 2 * leavesTotal, it will almost certainly be slower for all map dimensions.
-    """
-    stateUniversal = outfitCountFolds(listDimensions, computationDivisions=computationDivisions, CPUlimit=CPUlimit, **keywordArguments)
-
-    pathFilenameFoldsTotal = None
-    if pathishWriteFoldsTotal is not None:
-        pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateUniversal['mapShape'], pathishWriteFoldsTotal)
-
-    from mapFolding.babbage import _countFolds
-    _countFolds(**stateUniversal)
-
-    foldsTotal = stateUniversal['foldGroups'][0:-1].sum() * stateUniversal['foldGroups'][-1]
-
-    if pathFilenameFoldsTotal is not None:
-        saveFoldsTotal(pathFilenameFoldsTotal, foldsTotal)
-
-    return foldsTotal