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

mapFolding/theSSOT.py

@@ -1,76 +0,0 @@
-from typing import Any, Tuple, TypedDict
-import enum
-import numpy
-import numpy.typing
-import pathlib
-import sys
-
-datatypeModule = 'numpy'
-
-datatypeLarge = 'int64'
-datatypeDefault = datatypeLarge
-datatypeSmall = datatypeDefault
-
-make_dtype = lambda _datatype: eval(f"{datatypeModule}.{_datatype}")
-
-dtypeLarge = make_dtype(datatypeLarge)
-dtypeDefault = make_dtype(datatypeDefault)
-dtypeSmall = make_dtype(datatypeSmall)
-
-try:
-    _pathModule = pathlib.Path(__file__).parent
-except NameError:
-    _pathModule = pathlib.Path.cwd()
-
-pathJobDEFAULT = _pathModule / "jobs"
-
-if 'google.colab' in sys.modules:
-    pathJobDEFAULT = pathlib.Path("/content/drive/MyDrive") / "jobs"
-
-@enum.verify(enum.CONTINUOUS, enum.UNIQUE) if sys.version_info >= (3, 11) else lambda x: x
-class EnumIndices(enum.IntEnum):
-    """Base class for index enums."""
-    @staticmethod
-    def _generate_next_value_(name, start, count, last_values):
-        """0-indexed."""
-        return count
-
-    def __index__(self) -> int:
-        """Adapt enum to the ultra-rare event of indexing a NumPy 'ndarray', which is not the
-        same as `array.array`. See NumPy.org; I think it will be very popular someday."""
-        return self.value
-
-class indexMy(EnumIndices):
-    """Indices for dynamic values."""
-    dimensionsTotal = enum.auto() # connectionGraph.shape[0]
-    dimensionsUnconstrained = enum.auto()
-    gap1ndex = enum.auto()
-    gap1ndexCeiling = enum.auto()
-    indexDimension = enum.auto()
-    indexLeaf = enum.auto()
-    indexMiniGap = enum.auto()
-    leaf1ndex = enum.auto()
-    leafConnectee = enum.auto()
-    taskDivisions = enum.auto()
-    taskIndex = enum.auto()
-
-# class indexThe(EnumIndices):
-#     """Indices for static values."""
-#     dimensionsTotal = enum.auto() # connectionGraph.shape[0]
-#     taskDivisions = enum.auto()
-
-class indexTrack(EnumIndices):
-    """Indices for state tracking array."""
-    leafAbove = enum.auto()
-    leafBelow = enum.auto()
-    countDimensionsGapped = enum.auto()
-    gapRangeStart = enum.auto()
-
-class computationState(TypedDict):
-    connectionGraph: numpy.typing.NDArray[numpy.integer[Any]]
-    foldGroups: numpy.typing.NDArray[numpy.integer[Any]]
-    gapsWhere: numpy.typing.NDArray[numpy.integer[Any]]
-    mapShape: Tuple[int, ...]
-    my: numpy.typing.NDArray[numpy.integer[Any]]
-    # the: numpy.typing.NDArray[numpy.integer[Any]]
-    track: numpy.typing.NDArray[numpy.integer[Any]]

mapFolding-0.2.6.dist-info/RECORD

@@ -1,33 +0,0 @@
-mapFolding/__init__.py,sha256=yZ_rcMMCco346M62nKzp90GPp9OV1UkkWSxKzP3ISPA,380
-mapFolding/babbage.py,sha256=IfUoov6WYf9ExpnUoOMgw17GmaLueWseANelnTjomUk,2144
-mapFolding/beDRY.py,sha256=SLN7Rmo8pZ1tXoV4ZDeXDrHoOpoRMxBiq1F2E_ngtIw,15496
-mapFolding/importSelector.py,sha256=uVdA2oUoo11Cq1QXfRslgvzdrkTUIWXzqN6-eADK1bA,373
-mapFolding/lovelace.py,sha256=1HIkzuI3SQ6HCAVcGKpHt6Q9IFneYddGa1V8xkwTy7Y,14967
-mapFolding/oeis.py,sha256=_-fLGc1ybZ2eFxoiBrSmojMexeg6ROxtrLaBF2BzMn4,12144
-mapFolding/startHere.py,sha256=7VShI9OHHb-CqSkQ4XHKSp2zGpbN0hue3xDD-HHpyuY,3922
-mapFolding/theSSOT.py,sha256=v31S2Z4A_x5si5UZHoVxhvVpMLYdknN79FQrFwZO0q4,2414
-mapFolding/benchmarks/benchmarking.py,sha256=HD_0NSvuabblg94ftDre6LFnXShTe8MYj3hIodW-zV0,3076
-mapFolding/reference/flattened.py,sha256=X9nvRzg7YDcpCtSDTL4YiidjshlX9rg2e6JVCY6i2u0,16547
-mapFolding/reference/hunterNumba.py,sha256=0giUyqAFzP-XKcq3Kz8wIWCK0BVFhjABVJ1s-w4Jhu0,7109
-mapFolding/reference/irvineJavaPort.py,sha256=Sj-63Z-OsGuDoEBXuxyjRrNmmyl0d7Yz_XuY7I47Oyg,4250
-mapFolding/reference/jax.py,sha256=bB34dGdi3VSz4cRFbmCPn_erAmQ3FyrSED8uJ7CsES0,14961
-mapFolding/reference/lunnan.py,sha256=XEcql_gxvCCghb6Or3qwmPbn4IZUbZTaSmw_fUjRxZE,5037
-mapFolding/reference/lunnanNumpy.py,sha256=HqDgSwTOZA-G0oophOEfc4zs25Mv4yw2aoF1v8miOLk,4653
-mapFolding/reference/lunnanWhile.py,sha256=7NY2IKO5XBgol0aWWF_Fi-7oTL9pvu_z6lB0TF1uVHk,4063
-mapFolding/reference/rotatedEntryPoint.py,sha256=z0QyDQtnMvXNj5ntWzzJUQUMFm1-xHGLVhtYzwmczUI,11530
-mapFolding/reference/total_countPlus1vsPlusN.py,sha256=usenM8Yn_G1dqlPl7NKKkcnbohBZVZBXTQRm2S3_EDA,8106
-mapFolding/someAssemblyRequired/inlineAfunction.py,sha256=JrmLc2w6MciC8nsxpIzea5rqQPxZi97e60irBxkHzro,6201
-mapFolding/someAssemblyRequired/jobsAndTasks.py,sha256=PR1waaYHMhUzNjRm6cgVg_AukLtKzLb2_NSOIn9APDY,2238
-mapFolding/someAssemblyRequired/makeNuitkaSource.py,sha256=jTK34OWzm6OsgFPd2mHwETxFo2X83io0M4YiEHRgk3U,3262
-mapFolding/someAssemblyRequired/makeNumbaJob.py,sha256=i9vYBfqtZdZp1sPEQ1McFao0pq4s_Ppo4VSkS4SFozU,5823
-tests/__init__.py,sha256=eg9smg-6VblOr0kisM40CpGnuDtU2JgEEWGDTFVOlW8,57
-tests/conftest.py,sha256=Xj-R4yTq5h8lVVKhPSh3UooI9rXzfjZhYw8sP-oYDcc,13588
-tests/pythons_idiotic_namespace.py,sha256=oOLDBergQqqhGuRpsXUnFD-R_6AlJipNKYHw-kk_OKw,33
-tests/test_oeis.py,sha256=vxnwO-cSR68htkyMh9QMVv-lvxBo6qlwPg1Rbx4JylY,7963
-tests/test_other.py,sha256=98W-xsNQQuxYd4OiaRWUG7rcr4E5Q3SLCIMOjxr7FEo,12820
-tests/test_tasks.py,sha256=Nwe4iuSjwGZvsw5CXCcic7tkBxgM5JX9mrGZMDYhAwE,1785
-mapFolding-0.2.6.dist-info/METADATA,sha256=8oni55uKek5pb5Hw8Mu3ISUJHUTYV3w0HYm2eLk0eGA,6652
-mapFolding-0.2.6.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.2.6.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.2.6.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapFolding-0.2.6.dist-info/RECORD,,

mapFolding-0.2.6.dist-info/top_level.txt

@@ -1,2 +0,0 @@
-mapFolding
-tests

tests/__init__.py

@@ -1 +0,0 @@
-from tests.conftest import makeDictionaryFoldsTotalKnown

tests/conftest.py

@@ -1,343 +0,0 @@
-"""SSOT for Pytest"""
-
-# TODO learn how to run tests and coverage analysis without `env = ["NUMBA_DISABLE_JIT=1"]`
-
-from typing import Any, Callable, Dict, Generator, List, Optional, Sequence, Set, Tuple, Type, Union
-import pathlib
-import pytest
-import random
-import shutil
-import unittest.mock
-import uuid
-from Z0Z_tools.pytest_parseParameters import makeTestSuiteConcurrencyLimit
-from Z0Z_tools.pytest_parseParameters import makeTestSuiteIntInnit
-from Z0Z_tools.pytest_parseParameters import makeTestSuiteOopsieKwargsie
-from mapFolding import countFolds, pathJobDEFAULT, indexMy, indexTrack, saveFoldsTotal
-from mapFolding import defineConcurrencyLimit, intInnit, oopsieKwargsie, outfitCountFolds
-from mapFolding import oeisIDfor_n, getOEISids, clearOEIScache, getFilenameFoldsTotal
-from mapFolding.beDRY import getLeavesTotal, parseDimensions, validateListDimensions
-from mapFolding.beDRY import getTaskDivisions, makeConnectionGraph, setCPUlimit
-from mapFolding.beDRY import makeDataContainer
-from mapFolding.oeis import OEIS_for_n
-from mapFolding.oeis import _getFilenameOEISbFile
-from mapFolding.oeis import _getOEISidValues
-from mapFolding.oeis import _parseBFileOEIS
-from mapFolding.oeis import _validateOEISid
-from mapFolding.oeis import oeisIDsImplemented
-from mapFolding.oeis import settingsOEIS
-
-__all__ = [
-    'OEIS_for_n',
-    '_getFilenameOEISbFile',
-    '_getOEISidValues',
-    '_parseBFileOEIS',
-    '_validateOEISid',
-    'clearOEIScache',
-    'countFolds',
-    'defineConcurrencyLimit',
-    'expectSystemExit',
-    'getFilenameFoldsTotal',
-    'getLeavesTotal',
-    'getOEISids',
-    'getTaskDivisions',
-    'intInnit',
-    'makeConnectionGraph',
-    'makeDataContainer',
-    'makeTestSuiteConcurrencyLimit',
-    'makeTestSuiteIntInnit',
-    'makeTestSuiteOopsieKwargsie',
-    'oeisIDfor_n',
-    'oeisIDsImplemented',
-    'oopsieKwargsie',
-    'outfitCountFolds',
-    'parseDimensions',
-    'saveFoldsTotal',
-    'setCPUlimit',
-    'settingsOEIS',
-    'standardCacheTest',
-    'standardComparison',
-    'validateListDimensions',
-    ]
-
-def makeDictionaryFoldsTotalKnown() -> Dict[Tuple[int,...], int]:
-    """Returns a dictionary mapping dimension tuples to their known folding totals."""
-    dictionaryMapDimensionsToFoldsTotalKnown = {}
-
-    for settings in settingsOEIS.values():
-        sequence = settings['valuesKnown']
-
-        for n, foldingsTotal in sequence.items():
-            dimensions = settings['getDimensions'](n)
-            dimensions.sort()
-            dictionaryMapDimensionsToFoldsTotalKnown[tuple(dimensions)] = foldingsTotal
-
-    # Are we in a place that has jobs?
-    if pathJobDEFAULT.exists():
-        # Are there foldsTotal files?
-        for pathFilenameFoldsTotal in pathJobDEFAULT.rglob('*.foldsTotal'):
-            if pathFilenameFoldsTotal.is_file():
-                try:
-                    listDimensions = eval(pathFilenameFoldsTotal.stem)
-                except Exception:
-                    continue
-                # Are the dimensions in the dictionary?
-                if isinstance(listDimensions, list) and all(isinstance(dimension, int) for dimension in listDimensions):
-                    listDimensions.sort()
-                    if tuple(listDimensions) in dictionaryMapDimensionsToFoldsTotalKnown:
-                        continue
-                    # Are the contents a reasonably large integer?
-                    try:
-                        foldsTotal = pathFilenameFoldsTotal.read_text()
-                    except Exception:
-                        continue
-                    # Why did I sincerely believe this would only be three lines of code?
-                    if foldsTotal.isdigit() and int(foldsTotal) > 85109616 * 10**3:
-                        foldsTotal = int(foldsTotal)
-                    # You made it this far, so fuck it: put it in the dictionary
-                    dictionaryMapDimensionsToFoldsTotalKnown[tuple(listDimensions)] = foldsTotal
-                    # The sunk-costs fallacy claims another victim!
-
-    return dictionaryMapDimensionsToFoldsTotalKnown
-
-"""
-Section: temporary paths and pathFilenames"""
-
-# SSOT for test data paths
-pathDataSamples = pathlib.Path("tests/dataSamples")
-pathTempRoot = pathDataSamples / "tmp"
-
-# The registrar maintains the register of temp files
-registerOfTempFiles: Set[pathlib.Path] = set()
-
-def addTempFileToRegister(path: pathlib.Path) -> None:
-    """The registrar adds a temp file to the register."""
-    registerOfTempFiles.add(path)
-
-def cleanupTempFileRegister() -> None:
-    """The registrar cleans up temp files in the register."""
-    for pathTemp in sorted(registerOfTempFiles, reverse=True):
-        try:
-            if pathTemp.is_file():
-                pathTemp.unlink(missing_ok=True)
-            elif pathTemp.is_dir():
-                shutil.rmtree(pathTemp, ignore_errors=True)
-        except Exception as ERRORmessage:
-            print(f"Warning: Failed to clean up {pathTemp}: {ERRORmessage}")
-    registerOfTempFiles.clear()
-
-@pytest.fixture(scope="session", autouse=True)
-def setupTeardownTestData() -> Generator[None, None, None]:
-    """Auto-fixture to setup test data directories and cleanup after."""
-    pathDataSamples.mkdir(exist_ok=True)
-    pathTempRoot.mkdir(exist_ok=True)
-    yield
-    cleanupTempFileRegister()
-
-@pytest.fixture(autouse=True)
-def setupWarningsAsErrors():
-    """Convert all warnings to errors for all tests."""
-    import warnings
-    warnings.filterwarnings("error")
-    yield
-    warnings.resetwarnings()
-
-@pytest.fixture
-def pathTempTesting(request: pytest.FixtureRequest) -> pathlib.Path:
-    """Create a unique temp directory for each test function."""
-    # Sanitize test name for filesystem compatibility
-    sanitizedName = request.node.name.replace('[', '_').replace(']', '_').replace('/', '_')
-    uniqueDirectory = f"{sanitizedName}_{uuid.uuid4()}"
-    pathTemp = pathTempRoot / uniqueDirectory
-    pathTemp.mkdir(parents=True, exist_ok=True)
-
-    addTempFileToRegister(pathTemp)
-    return pathTemp
-
-@pytest.fixture
-def pathCacheTesting(pathTempTesting: pathlib.Path) -> Generator[pathlib.Path, Any, None]:
-    """Temporarily replace the OEIS cache directory with a test directory."""
-    from mapFolding import oeis as there_must_be_a_better_way
-    pathCacheOriginal = there_must_be_a_better_way._pathCache
-    there_must_be_a_better_way._pathCache = pathTempTesting
-    yield pathTempTesting
-    there_must_be_a_better_way._pathCache = pathCacheOriginal
-
-@pytest.fixture
-def pathFilenameBenchmarksTesting(pathTempTesting: pathlib.Path) -> Generator[pathlib.Path, Any, None]:
-    """Temporarily replace the benchmarks directory with a test directory."""
-    from mapFolding.benchmarks import benchmarking
-    pathFilenameOriginal = benchmarking.pathFilenameRecordedBenchmarks
-    pathFilenameTest = pathTempTesting / "benchmarks.npy"
-    benchmarking.pathFilenameRecordedBenchmarks = pathFilenameTest
-    yield pathFilenameTest
-    benchmarking.pathFilenameRecordedBenchmarks = pathFilenameOriginal
-
-@pytest.fixture
-def pathFilenameFoldsTotalTesting(pathTempTesting: pathlib.Path) -> pathlib.Path:
-    return pathTempTesting.joinpath("foldsTotalTest.txt")
-
-"""
-Section: Fixtures"""
-
-@pytest.fixture
-def foldsTotalKnown() -> Dict[Tuple[int,...], int]:
-    """Returns a dictionary mapping dimension tuples to their known folding totals.
-    NOTE I am not convinced this is the best way to do this.
-    Advantage: I call `makeDictionaryFoldsTotalKnown()` from modules other than test modules.
-    Preference: I _think_ I would prefer a SSOT function available to any module
-    similar to `foldsTotalKnown = getFoldsTotalKnown(listDimensions)`."""
-    return makeDictionaryFoldsTotalKnown()
-
-@pytest.fixture
-def listDimensionsTestFunctionality(oeisID_1random: str) -> List[int]:
-    """To test functionality, get one `listDimensions` from `valuesTestValidation` if
-    `validateListDimensions` approves. The algorithm can count the folds of the returned
-    `listDimensions` in a short enough time suitable for testing."""
-    while True:
-        n = random.choice(settingsOEIS[oeisID_1random]['valuesTestValidation'])
-        if n < 2:
-            continue
-        listDimensionsCandidate = settingsOEIS[oeisID_1random]['getDimensions'](n)
-
-        try:
-            return validateListDimensions(listDimensionsCandidate)
-        except (ValueError, NotImplementedError):
-            pass
-
-@pytest.fixture
-def listDimensionsTest_countFolds(oeisID: str) -> List[int]:
-    """For each `oeisID` from the `pytest.fixture`, returns `listDimensions` from `valuesTestValidation`
-    if `validateListDimensions` approves. Each `listDimensions` is suitable for testing counts."""
-    while True:
-        n = random.choice(settingsOEIS[oeisID]['valuesTestValidation'])
-        if n < 2:
-            continue
-        listDimensionsCandidate = settingsOEIS[oeisID]['getDimensions'](n)
-
-        try:
-            return validateListDimensions(listDimensionsCandidate)
-        except (ValueError, NotImplementedError):
-            pass
-
-@pytest.fixture
-def mockBenchmarkTimer() -> Generator[unittest.mock.MagicMock | unittest.mock.AsyncMock, Any, None]:
-    """Mock time.perf_counter_ns for consistent benchmark timing."""
-    with unittest.mock.patch('time.perf_counter_ns') as mockTimer:
-        mockTimer.side_effect = [0, 1e9]  # Start and end times for 1 second
-        yield mockTimer
-
-@pytest.fixture(params=oeisIDsImplemented)
-def oeisID(request: pytest.FixtureRequest)-> str:
-    return request.param
-
-@pytest.fixture
-def oeisID_1random() -> str:
-    """Return one random valid OEIS ID."""
-    return random.choice(oeisIDsImplemented)
-
-@pytest.fixture
-def mockFoldingFunction():
-    """Creates a mock function that simulates _countFolds behavior."""
-    def make_mock(foldsValue: int, listDimensions: List[int]):
-        mock_array = makeDataContainer(2)
-        mock_array[0] = foldsValue
-        mock_array[-1] = getLeavesTotal(listDimensions)
-
-        def mock_countfolds(**keywordArguments):
-            keywordArguments['foldGroups'][:] = mock_array
-            return None
-
-        return mock_countfolds
-    return make_mock
-
-"""
-Section: Standardized test structures"""
-
-def formatTestMessage(expected: Any, actual: Any, functionName: str, *arguments: Any) -> str:
-    """Format assertion message for any test comparison."""
-    return (f"\nTesting: `{functionName}({', '.join(str(parameter) for parameter in arguments)})`\n"
-            f"Expected: {expected}\n"
-            f"Got: {actual}")
-
-def standardComparison(expected: Any, functionTarget: Callable, *arguments: Any) -> None:
-    """Template for tests expecting an error."""
-    if type(expected) == Type[Exception]:
-        messageExpected = expected.__name__
-    else:
-        messageExpected = expected
-
-    try:
-        messageActual = actual = functionTarget(*arguments)
-    except Exception as actualError:
-        messageActual = type(actualError).__name__
-        actual = type(actualError)
-
-    assert actual == expected, formatTestMessage(messageExpected, messageActual, functionTarget.__name__, *arguments)
-
-def expectSystemExit(expected: Union[str, int, Sequence[int]], functionTarget: Callable, *arguments: Any) -> None:
-    """Template for tests expecting SystemExit.
-
-    Parameters
-        expected: Exit code expectation:
-            - "error": any non-zero exit code
-            - "nonError": specifically zero exit code
-            - int: exact exit code match
-            - Sequence[int]: exit code must be one of these values
-        functionTarget: The function to test
-        arguments: Arguments to pass to the function
-    """
-    with pytest.raises(SystemExit) as exitInfo:
-        functionTarget(*arguments)
-
-    exitCode = exitInfo.value.code
-
-    if expected == "error":
-        assert exitCode != 0, \
-            f"Expected error exit (non-zero) but got code {exitCode}"
-    elif expected == "nonError":
-        assert exitCode == 0, \
-            f"Expected non-error exit (0) but got code {exitCode}"
-    elif isinstance(expected, (list, tuple)):
-        assert exitCode in expected, \
-            f"Expected exit code to be one of {expected} but got {exitCode}"
-    else:
-        assert exitCode == expected, \
-            f"Expected exit code {expected} but got {exitCode}"
-
-def standardCacheTest(
-    expected: Any,
-    setupCacheFile: Optional[Callable[[pathlib.Path, str], None]],
-    oeisID: str,
-    pathCache: pathlib.Path
-) -> None:
-    """Template for tests involving OEIS cache operations.
-
-    Parameters
-        expected: Expected value or exception from _getOEISidValues
-        setupCacheFile: Function to prepare the cache file before test
-        oeisID: OEIS ID to test
-        pathCache: Temporary cache directory path
-    """
-    pathFilenameCache = pathCache / _getFilenameOEISbFile(oeisID)
-
-    # Setup cache file if provided
-    if setupCacheFile:
-        setupCacheFile(pathFilenameCache, oeisID)
-
-    # Run test
-    try:
-        actual = _getOEISidValues(oeisID)
-        messageActual = actual
-    except Exception as actualError:
-        actual = type(actualError)
-        messageActual = type(actualError).__name__
-
-    # Compare results
-    if isinstance(expected, type) and issubclass(expected, Exception):
-        messageExpected = expected.__name__
-        assert isinstance(actual, expected), formatTestMessage(
-            messageExpected, messageActual, "_getOEISidValues", oeisID)
-    else:
-        messageExpected = expected
-        assert actual == expected, formatTestMessage(
-            messageExpected, messageActual, "_getOEISidValues", oeisID)

tests/pythons_idiotic_namespace.py

@@ -1 +0,0 @@
-from mapFolding.theSSOT import *

tests/test_oeis.py

@@ -1,194 +0,0 @@
-from tests.conftest import *
-from contextlib import redirect_stdout
-from datetime import datetime, timedelta
-from typing import Optional, Tuple, Union
-import io
-import os
-import pathlib
-import pytest
-import random
-import re as regex
-import unittest
-import unittest.mock
-import urllib.error
-import urllib.request
-
-def test_aOFn_calculate_value(oeisID: str):
-    for n in settingsOEIS[oeisID]['valuesTestValidation']:
-        standardComparison(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
-
-@pytest.mark.parametrize("badID", ["A999999", "  A999999  ", "A999999extra"])
-def test__validateOEISid_invalid_id(badID: str):
-    standardComparison(KeyError, _validateOEISid, badID)
-
-def test__validateOEISid_partially_valid(oeisID_1random: str):
-    standardComparison(KeyError, _validateOEISid, f"{oeisID_1random}extra")
-
-def test__validateOEISid_valid_id(oeisID: str):
-    standardComparison(oeisID, _validateOEISid, oeisID)
-
-def test__validateOEISid_valid_id_case_insensitive(oeisID: str):
-    standardComparison(oeisID.upper(), _validateOEISid, oeisID.lower())
-    standardComparison(oeisID.upper(), _validateOEISid, oeisID.upper())
-    standardComparison(oeisID.upper(), _validateOEISid, oeisID.swapcase())
-
-parameters_test_aOFn_invalid_n = [
-    # (2, "ok"), # test the test template
-    (-random.randint(1, 100), "randomNegative"),
-    ("foo", "string"),
-    (1.5, "float")
-]
-badValues, badValuesIDs = zip(*parameters_test_aOFn_invalid_n)
-@pytest.mark.parametrize("badN", badValues, ids=badValuesIDs)
-def test_aOFn_invalid_n(oeisID_1random: str, badN):
-    """Check that negative or non-integer n raises ValueError."""
-    standardComparison(ValueError, oeisIDfor_n, oeisID_1random, badN)
-
-def test_aOFn_zeroDim_A001418():
-    standardComparison(ArithmeticError, oeisIDfor_n, 'A001418', 0)
-
-# ===== OEIS Cache Tests =====
-@pytest.mark.parametrize("cacheExists", [True, False])
-@unittest.mock.patch('pathlib.Path.exists')
-@unittest.mock.patch('pathlib.Path.unlink')
-def test_clearOEIScache(mock_unlink: unittest.mock.MagicMock, mock_exists: unittest.mock.MagicMock, cacheExists: bool):
-    """Test OEIS cache clearing with both existing and non-existing cache."""
-    mock_exists.return_value = cacheExists
-    clearOEIScache()
-
-    if cacheExists:
-        assert mock_unlink.call_count == len(settingsOEIS)
-        mock_unlink.assert_has_calls([unittest.mock.call(missing_ok=True)] * len(settingsOEIS))
-    else:
-        mock_exists.assert_called_once()
-        mock_unlink.assert_not_called()
-
-@pytest.mark.parametrize("scenarioCache", ["miss", "expired", "invalid"])
-def testCacheScenarios(pathCacheTesting: pathlib.Path, oeisID_1random: str, scenarioCache: str) -> None:
-    """Test cache scenarios: missing file, expired file, and invalid file."""
-
-    def setupCacheExpired(pathCache: pathlib.Path, oeisID: str) -> None:
-        pathCache.write_text("# Old cache content")
-        oldModificationTime = datetime.now() - timedelta(days=30)
-        os.utime(pathCache, times=(oldModificationTime.timestamp(), oldModificationTime.timestamp()))
-
-    def setupCacheInvalid(pathCache: pathlib.Path, oeisID: str) -> None:
-        pathCache.write_text("Invalid content")
-
-    if scenarioCache == "miss":
-        standardCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], None, oeisID_1random, pathCacheTesting)
-    elif scenarioCache == "expired":
-        standardCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], setupCacheExpired, oeisID_1random, pathCacheTesting)
-    else:
-        standardCacheTest(settingsOEIS[oeisID_1random]['valuesKnown'], setupCacheInvalid, oeisID_1random, pathCacheTesting)
-
-def testInvalidFileContent(pathCacheTesting: pathlib.Path, oeisID_1random: str):
-    pathFilenameCache = pathCacheTesting / _getFilenameOEISbFile(oeisID=oeisID_1random)
-
-    # Write invalid content to cache
-    pathFilenameCache.write_text("# A999999\n1 1\n2 2\n")
-    modificationTimeOriginal = pathFilenameCache.stat().st_mtime
-
-    # Function should detect invalid content, fetch fresh data, and update cache
-    OEISsequence = _getOEISidValues(oeisID_1random)
-
-    # Verify the function succeeded
-    assert OEISsequence is not None
-    # Verify cache was updated (modification time changed)
-    assert pathFilenameCache.stat().st_mtime > modificationTimeOriginal
-    # Verify cache now contains correct sequence ID
-    assert f"# {oeisID_1random}" in pathFilenameCache.read_text()
-
-def testParseContentErrors():
-    """Test invalid content parsing."""
-    standardComparison(ValueError, _parseBFileOEIS, "Invalid content\n1 2\n", 'A001415')
-
-def testExtraComments(pathCacheTesting: pathlib.Path, oeisID_1random: str):
-    pathFilenameCache = pathCacheTesting / _getFilenameOEISbFile(oeisID=oeisID_1random)
-
-    # Write content with extra comment lines
-    contentWithExtraComments = f"""# {oeisID_1random}
-# Normal place for comment line 1
-# Abnormal comment line
-1 2
-2 4
-3 6
-# Another comment in the middle
-4 8
-5 10"""
-    pathFilenameCache.write_text(contentWithExtraComments)
-
-    OEISsequence = _getOEISidValues(oeisID_1random)
-    # Verify sequence values are correct despite extra comments
-    standardComparison(2, lambda d: d[1], OEISsequence)  # First value
-    standardComparison(8, lambda d: d[4], OEISsequence)  # Value after mid-sequence comment
-    standardComparison(10, lambda d: d[5], OEISsequence)  # Last value
-
-def testNetworkError(monkeypatch: pytest.MonkeyPatch, pathCacheTesting: pathlib.Path):
-    """Test network error handling."""
-    def mockUrlopen(*args, **kwargs):
-        raise urllib.error.URLError("Network error")
-
-    monkeypatch.setattr(urllib.request, 'urlopen', mockUrlopen)
-    standardComparison(urllib.error.URLError, _getOEISidValues, next(iter(settingsOEIS)))
-
-# ===== Command Line Interface Tests =====
-def testHelpText():
-    """Test that help text is complete and examples are valid."""
-    outputStream = io.StringIO()
-    with redirect_stdout(outputStream):
-        getOEISids()
-
-    helpText = outputStream.getvalue()
-
-    # Verify content
-    for oeisID in oeisIDsImplemented:
-        assert oeisID in helpText
-        assert settingsOEIS[oeisID]['description'] in helpText
-
-    # Extract and verify examples
-
-    cliMatch = regex.search(r'OEIS_for_n (\w+) (\d+)', helpText)
-    pythonMatch = regex.search(r"oeisIDfor_n\('(\w+)', (\d+)\)", helpText)
-
-    assert cliMatch and pythonMatch, "Help text missing examples"
-    oeisID, n = pythonMatch.groups()
-    n = int(n)
-
-    # Verify CLI and Python examples use same values
-    assert cliMatch.groups() == (oeisID, str(n)), "CLI and Python examples inconsistent"
-
-    # Verify the example works
-    expectedValue = oeisIDfor_n(oeisID, n)
-
-    # Test CLI execution of the example
-    with unittest.mock.patch('sys.argv', ['OEIS_for_n', oeisID, str(n)]):
-        outputStream = io.StringIO()
-        with redirect_stdout(outputStream):
-            OEIS_for_n()
-        standardComparison(expectedValue, lambda: int(outputStream.getvalue().strip().split()[0]))
-
-def testCLI_InvalidInputs():
-    """Test CLI error handling."""
-    testCases = [
-        (['OEIS_for_n'], "missing arguments"),
-        (['OEIS_for_n', 'A999999', '1'], "invalid OEIS ID"),
-        (['OEIS_for_n', 'A001415', '-1'], "negative n"),
-        (['OEIS_for_n', 'A001415', 'abc'], "non-integer n"),
-    ]
-
-    for arguments, testID in testCases:
-        with unittest.mock.patch('sys.argv', arguments):
-            expectSystemExit("error", OEIS_for_n)
-
-def testCLI_HelpFlag():
-    """Verify --help output contains required information."""
-    with unittest.mock.patch('sys.argv', ['OEIS_for_n', '--help']):
-        outputStream = io.StringIO()
-        with redirect_stdout(outputStream):
-            expectSystemExit("nonError", OEIS_for_n)
-
-        helpOutput = outputStream.getvalue()
-        assert "Available OEIS sequences:" in helpOutput
-        assert "Usage examples:" in helpOutput
-        assert all(oeisID in helpOutput for oeisID in oeisIDsImplemented)