mapFolding 0.6.0__tar.gz → 0.7.0__tar.gz

{mapfolding-0.6.0 → mapfolding-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.6.0
+Version: 0.7.0
 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
@@ -8,7 +8,7 @@ Project-URL: Donate, https://www.patreon.com/integrated
 Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
 Project-URL: Repository, https://github.com/hunterhogan/mapFolding.git
 Keywords: A001415,A001416,A001417,A001418,A195646,combinatorics,folding,map folding,OEIS,optimization,stamp folding
-Classifier: Development Status :: 5 - Production/Stable
+Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Education
 Classifier: Intended Audience :: End Users/Desktop
@@ -28,19 +28,20 @@ Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: autoflake
+Requires-Dist: more_itertools
+Requires-Dist: numba_progress
 Requires-Dist: numba
 Requires-Dist: numpy
+Requires-Dist: python_minifier
+Requires-Dist: tomli
 Requires-Dist: Z0Z_tools
 Provides-Extra: testing
-Requires-Dist: autoflake; extra == "testing"
 Requires-Dist: mypy; extra == "testing"
-Requires-Dist: more_itertools; extra == "testing"
-Requires-Dist: numba_progress; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pytest-env; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
-Requires-Dist: python_minifier; extra == "testing"
 Requires-Dist: pyupgrade; extra == "testing"
 Requires-Dist: updateCitation; extra == "testing"
 

mapfolding-0.7.0/mapFolding/__init__.py

@@ -0,0 +1,9 @@
+from mapFolding.basecamp import countFolds
+from mapFolding.oeis import clearOEIScache, getOEISids, OEIS_for_n
+
+__all__ = [
+	'clearOEIScache',
+	'countFolds',
+	'getOEISids',
+	'OEIS_for_n',
+]

{mapfolding-0.6.0 → mapfolding-0.7.0}/mapFolding/basecamp.py

@@ -1,5 +1,7 @@
 from collections.abc import Sequence
-from mapFolding import computationState, getDispatcherCallable, getPathFilenameFoldsTotal, outfitCountFolds, saveFoldsTotal
+from mapFolding.beDRY import outfitCountFolds, setCPUlimit, validateListDimensions
+from mapFolding.filesystem import getPathFilenameFoldsTotal, saveFoldsTotal
+from mapFolding.theSSOT import ComputationState, getPackageDispatcher
 from os import PathLike
 from pathlib import Path
 
@@ -37,15 +39,17 @@ def countFolds(listDimensions: Sequence[int]
 	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: computationState = outfitCountFolds(listDimensions, computationDivisions=computationDivisions, CPUlimit=CPUlimit)
+	mapShape: tuple[int, ...] = validateListDimensions(listDimensions)
+	concurrencyLimit: int = setCPUlimit(CPUlimit)
+	computationStateInitialized: ComputationState = outfitCountFolds(mapShape, computationDivisions, concurrencyLimit)
 
-	dispatcher = getDispatcherCallable()
-	dispatcher(**stateUniversal)
+	dispatcher = getPackageDispatcher()
+	computationStateComplete: ComputationState = dispatcher(computationStateInitialized)
 
-	foldsTotal = int(stateUniversal['foldGroups'][0:-1].sum() * stateUniversal['foldGroups'][-1])
+	computationStateComplete.getFoldsTotal()
 
 	if pathLikeWriteFoldsTotal is not None:
-		pathFilenameFoldsTotal: Path = getPathFilenameFoldsTotal(stateUniversal['mapShape'], pathLikeWriteFoldsTotal)
-		saveFoldsTotal(pathFilenameFoldsTotal, foldsTotal)
+		pathFilenameFoldsTotal: Path = getPathFilenameFoldsTotal(computationStateComplete.mapShape, pathLikeWriteFoldsTotal)
+		saveFoldsTotal(pathFilenameFoldsTotal, computationStateComplete.foldsTotal)
 
-	return foldsTotal
+	return computationStateComplete.foldsTotal

mapfolding-0.7.0/mapFolding/beDRY.py

@@ -0,0 +1,164 @@
+"""A relatively stable API for oft-needed functionality."""
+from mapFolding.theSSOT import (
+	Array3D,
+	ComputationState,
+	getDatatypePackage,
+	getNumpyDtypeDefault,
+)
+from collections.abc import Sequence
+from sys import maxsize as sysMaxsize
+from typing import Any
+from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
+import numpy
+
+def validateListDimensions(listDimensions: Sequence[int]) -> tuple[int, ...]:
+	if not listDimensions:
+		raise ValueError("listDimensions is a required parameter.")
+	listValidated: list[int] = intInnit(listDimensions, 'listDimensions')
+	listNonNegative: list[int] = []
+	for dimension in listValidated:
+		if dimension < 0:
+			raise ValueError(f"Dimension {dimension} must be non-negative")
+		listNonNegative.append(dimension)
+	dimensionsValid = [dimension for dimension in listNonNegative if dimension > 0]
+	if len(dimensionsValid) < 2:
+		raise NotImplementedError(f"This function requires listDimensions, {listDimensions}, to have at least two dimensions greater than 0. You may want to look at https://oeis.org/.")
+	return tuple(sorted(dimensionsValid))
+
+def getLeavesTotal(mapShape: tuple[int, ...]) -> int:
+	productDimensions = 1
+	for dimension in mapShape:
+		if dimension > sysMaxsize // productDimensions:
+			raise OverflowError(f"I received {dimension=} in {mapShape=}, but the product of the dimensions exceeds the maximum size of an integer on this system.")
+		productDimensions *= dimension
+	return productDimensions
+
+def getNumpyDtype(datatype: type[numpy.signedinteger[Any]] | None = None) -> type[numpy.signedinteger[Any]]:
+	"""An imperfect way to reduce code duplication."""
+	if 'numpy' == getDatatypePackage():
+		numpyDtype = datatype or getNumpyDtypeDefault()
+	else:
+		raise NotImplementedError("Somebody done broke it.")
+	return numpyDtype
+
+def makeConnectionGraph(mapShape: tuple[int, ...], leavesTotal: int, datatype: type[numpy.signedinteger[Any]] | None = None) -> Array3D:
+	numpyDtype = getNumpyDtype(datatype)
+	dimensionsTotal = len(mapShape)
+	cumulativeProduct = numpy.multiply.accumulate([1] + list(mapShape), dtype=numpyDtype)
+	arrayDimensions = numpy.array(mapShape, dtype=numpyDtype)
+	coordinateSystem = numpy.zeros((dimensionsTotal, leavesTotal + 1), dtype=numpyDtype)
+	for indexDimension in range(dimensionsTotal):
+		for leaf1ndex in range(1, leavesTotal + 1):
+			coordinateSystem[indexDimension, leaf1ndex] = (((leaf1ndex - 1) // cumulativeProduct[indexDimension]) % arrayDimensions[indexDimension] + 1)
+
+	connectionGraph = numpy.zeros((dimensionsTotal, leavesTotal + 1, leavesTotal + 1), dtype=numpyDtype)
+	for indexDimension in range(dimensionsTotal):
+		for activeLeaf1ndex in range(1, leavesTotal + 1):
+			for connectee1ndex in range(1, activeLeaf1ndex + 1):
+				isFirstCoord = coordinateSystem[indexDimension, connectee1ndex] == 1
+				isLastCoord = coordinateSystem[indexDimension, connectee1ndex] == arrayDimensions[indexDimension]
+				exceedsActive = connectee1ndex + cumulativeProduct[indexDimension] > activeLeaf1ndex
+				isEvenParity = (coordinateSystem[indexDimension, activeLeaf1ndex] & 1) == (coordinateSystem[indexDimension, connectee1ndex] & 1)
+
+				if (isEvenParity and isFirstCoord) or (not isEvenParity and (isLastCoord or exceedsActive)):
+					connectionGraph[indexDimension, activeLeaf1ndex, connectee1ndex] = connectee1ndex
+				elif isEvenParity and not isFirstCoord:
+					connectionGraph[indexDimension, activeLeaf1ndex, connectee1ndex] = connectee1ndex - cumulativeProduct[indexDimension]
+				elif not isEvenParity and not (isLastCoord or exceedsActive):
+					connectionGraph[indexDimension, activeLeaf1ndex, connectee1ndex] = connectee1ndex + cumulativeProduct[indexDimension]
+	return connectionGraph
+
+def makeDataContainer(shape: int | tuple[int, ...], datatype: type[numpy.signedinteger[Any]] | None = None) -> numpy.ndarray[Any, numpy.dtype[numpy.signedinteger[Any]]]:
+	numpyDtype = getNumpyDtype(datatype)
+	return numpy.zeros(shape, dtype=numpyDtype)
+
+def setCPUlimit(CPUlimit: Any | None) -> int:
+	"""Sets CPU limit for Numba concurrent operations. Note that it can only affect Numba-jitted functions that have not yet been imported.
+
+	Parameters:
+		CPUlimit: whether and how to limit the CPU usage. See notes for details.
+	Returns:
+		concurrencyLimit: The actual concurrency limit that was set
+	Raises:
+		TypeError: If CPUlimit is not of the expected types
+
+	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.
+	"""
+	if not (CPUlimit is None or isinstance(CPUlimit, (bool, int, float))):
+		CPUlimit = oopsieKwargsie(CPUlimit)
+
+	concurrencyLimit: int = int(defineConcurrencyLimit(CPUlimit))
+	from mapFolding.theSSOT import concurrencyPackage
+	if concurrencyPackage == 'numba':
+		from numba import get_num_threads, set_num_threads
+		set_num_threads(concurrencyLimit)
+		concurrencyLimit = get_num_threads()
+	elif concurrencyPackage == 'algorithm':
+		concurrencyLimit = 1
+	else:
+		raise NotImplementedError("This function only supports the 'numba' concurrency package.")
+
+	return concurrencyLimit
+
+def getTaskDivisions(computationDivisions: int | str | None, concurrencyLimit: int, leavesTotal: int) -> int:
+	"""
+	Determines whether to divide the computation into tasks and how many divisions.
+
+	Parameters
+	----------
+	computationDivisions (None)
+		Specifies how to divide computations:
+		- `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`.
+	concurrencyLimit
+		Maximum number of concurrent tasks allowed.
+	CPUlimit
+		for error reporting.
+	listDimensions
+		for error reporting.
+
+	Returns
+	-------
+	taskDivisions
+		How many tasks must finish before the job can compute the total number of folds; `0` means no tasks, only job.
+
+	Raises
+	------
+	ValueError
+		If computationDivisions is an unsupported type or if resulting task divisions exceed total leaves.
+
+	Notes
+	-----
+	Task divisions should not exceed total leaves or the folds will be over-counted.
+	"""
+	taskDivisions = 0
+	if not computationDivisions:
+		pass
+	elif isinstance(computationDivisions, int):
+		taskDivisions = computationDivisions
+	elif isinstance(computationDivisions, str): # type: ignore 'Unnecessary isinstance call; "str" is always an instance of "str", so sayeth Pylance'. Yeah, well "User is not always an instance of "correct input" so sayeth the programmer.
+		computationDivisions = computationDivisions.lower()
+		if computationDivisions == 'maximum':
+			taskDivisions = leavesTotal
+		elif computationDivisions == 'cpu':
+			taskDivisions = min(concurrencyLimit, leavesTotal)
+	else:
+		raise ValueError(f"I received {computationDivisions} for the parameter, `computationDivisions`, but the so-called programmer didn't implement code for that.")
+
+	if taskDivisions > leavesTotal:
+		raise ValueError(f"Problem: `taskDivisions`, ({taskDivisions}), is greater than `leavesTotal`, ({leavesTotal}), which will cause duplicate counting of the folds.\n\nChallenge: you cannot directly set `taskDivisions` or `leavesTotal`. They are derived from parameters that may or may not still be named `computationDivisions`, `CPUlimit` , and `listDimensions` and from dubious-quality Python code.")
+	return int(max(0, taskDivisions))
+
+def outfitCountFolds(mapShape: tuple[int, ...], computationDivisions: int | str | None = None, concurrencyLimit: int = 1) -> ComputationState:
+	leavesTotal = getLeavesTotal(mapShape)
+	taskDivisions = getTaskDivisions(computationDivisions, concurrencyLimit, leavesTotal)
+	computationStateInitialized = ComputationState(mapShape, leavesTotal, taskDivisions)
+	return computationStateInitialized

mapfolding-0.7.0/mapFolding/filesystem.py

@@ -0,0 +1,87 @@
+"""Filesystem functions for mapFolding package."""
+from pathlib import Path
+import os
+
+def saveFoldsTotal(pathFilename: str | os.PathLike[str], foldsTotal: int) -> None:
+	"""
+	Save foldsTotal with multiple fallback mechanisms.
+
+	Parameters:
+		pathFilename: Target save location
+		foldsTotal: Critical computed value to save
+	"""
+	try:
+		pathFilenameFoldsTotal = Path(pathFilename)
+		pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
+		pathFilenameFoldsTotal.write_text(str(foldsTotal))
+	except Exception as ERRORmessage:
+		try:
+			print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
+			print(ERRORmessage)
+			print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
+			randomnessPlanB = (int(str(foldsTotal).strip()[-1]) + 1) * ['YO_']
+			filenameInfixUnique = ''.join(randomnessPlanB)
+			pathFilenamePlanB = os.path.join(os.getcwd(), 'foldsTotal' + filenameInfixUnique + '.txt')
+			writeStreamFallback = open(pathFilenamePlanB, 'w')
+			writeStreamFallback.write(str(foldsTotal))
+			writeStreamFallback.close()
+			print(str(pathFilenamePlanB))
+		except Exception:
+			print(foldsTotal)
+	return None
+
+def getFilenameFoldsTotal(mapShape: tuple[int, ...]) -> str:
+	"""Imagine your computer has been counting folds for 9 days, and when it tries to save your newly discovered value,
+	the filename is invalid. I bet you think this function is more important after that thought experiment.
+
+	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
+		- unique extension
+		- Python-safe strings:
+			- no starting with a number
+			- no reserved words
+			- no dashes or other special characters
+			- uh, I can't remember, but I found some other frustrating limitations
+		- if 'p' is still the first character of the filename, 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.
+
+	Returns:
+		filenameFoldsTotal: A filename string in format 'pMxN.foldsTotal' where M,N are sorted dimensions
+	"""
+	return 'p' + 'x'.join(str(dimension) for dimension in sorted(mapShape)) + '.foldsTotal'
+
+def getPathFilenameFoldsTotal(mapShape: tuple[int, ...], pathLikeWriteFoldsTotal: str | os.PathLike[str] | None = None) -> Path:
+	"""Get a standardized path and filename for the computed value `foldsTotal`.
+
+	If you provide a directory, the function will append a standardized filename. If you provide a filename
+	or a relative path and filename, the function will prepend the default path.
+
+	Parameters:
+		mapShape: List of dimensions for the map folding problem.
+		pathLikeWriteFoldsTotal (pathJobRootDEFAULT): Path, filename, or relative path and filename. If None, uses default path.
+			Defaults to None.
+
+	Returns:
+		pathFilenameFoldsTotal: Absolute path and filename.
+	"""
+	from mapFolding.theSSOT import getPathJobRootDEFAULT
+
+	if pathLikeWriteFoldsTotal is None:
+		pathFilenameFoldsTotal = getPathJobRootDEFAULT() / getFilenameFoldsTotal(mapShape)
+	else:
+		pathLikeSherpa = Path(pathLikeWriteFoldsTotal)
+		if pathLikeSherpa.is_dir():
+			pathFilenameFoldsTotal = pathLikeSherpa / getFilenameFoldsTotal(mapShape)
+		elif pathLikeSherpa.is_file() and pathLikeSherpa.is_absolute():
+			pathFilenameFoldsTotal = pathLikeSherpa
+		else:
+			pathFilenameFoldsTotal = getPathJobRootDEFAULT() / pathLikeSherpa
+
+	pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
+	return pathFilenameFoldsTotal

mapfolding-0.7.0/mapFolding/noHomeYet.py

@@ -0,0 +1,20 @@
+from functools import cache
+from mapFolding.oeis import settingsOEIS
+
+@cache
+def makeDictionaryFoldsTotalKnown() -> dict[tuple[int, ...], int]:
+	"""Returns a dictionary mapping dimension tuples to their known folding totals."""
+	dictionaryMapDimensionsToFoldsTotalKnown: dict[tuple[int, ...], int] = {}
+
+	for settings in settingsOEIS.values():
+		sequence = settings['valuesKnown']
+
+		for n, foldingsTotal in sequence.items():
+			mapShape = settings['getMapShape'](n)
+			mapShape = sorted(mapShape)
+			dictionaryMapDimensionsToFoldsTotalKnown[tuple(mapShape)] = foldingsTotal
+	return dictionaryMapDimensionsToFoldsTotalKnown
+
+def getFoldsTotalKnown(mapShape: tuple[int, ...]) -> int:
+	lookupFoldsTotal = makeDictionaryFoldsTotalKnown()
+	return lookupFoldsTotal.get(tuple(mapShape), -1)

{mapfolding-0.6.0 → mapfolding-0.7.0}/mapFolding/oeis.py

@@ -1,9 +1,9 @@
 """Everything implementing the The Online Encyclopedia of Integer Sequences (OEIS); _only_ things that implement _only_ the OEIS."""
 from collections.abc import Callable
 from datetime import datetime, timedelta
-from mapFolding import countFolds, pathPackage
+from mapFolding.theSSOT import thePathPackage
 from pathlib import Path
-from typing import Any, cast, Final, TYPE_CHECKING
+from typing import Any, Final, TYPE_CHECKING
 import argparse
 import pathlib
 import random
@@ -23,11 +23,11 @@ cacheDays = 7
 """
 Section: make `settingsOEIS`"""
 
-pathCache: Path = pathPackage / ".cache"
+pathCache: Path = thePathPackage / ".cache"
 
 class SettingsOEIS(TypedDict):
 	description: str
-	getMapShape: Callable[[int], list[int]]
+	getMapShape: Callable[[int], tuple[int, ...]]
 	offset: int
 	valuesBenchmark: list[int]
 	valuesKnown: dict[int, int]
@@ -35,38 +35,45 @@ class SettingsOEIS(TypedDict):
 	valuesTestValidation: list[int]
 	valueUnknown: int
 
-settingsOEIShardcodedValues: dict[str, dict[str, Any]] = {
-    'A001415': {
-        'getMapShape': cast(Callable[[int], list[int]], lambda n: sorted([2, n])), # type: ignore
-        'valuesBenchmark': [14],
-        'valuesTestParallelization': [*range(3, 7)],
-        'valuesTestValidation': [random.randint(2, 9)],
-    },
-    'A001416': {
-        'getMapShape': cast(Callable[[int], list[int]], lambda n: sorted([3, n])), # type: ignore
-        'valuesBenchmark': [9],
-        'valuesTestParallelization': [*range(3, 5)],
-        'valuesTestValidation': [random.randint(2, 6)],
-    },
-    'A001417': {
-        'getMapShape': cast(Callable[[int], list[int]], lambda n: [2] * n),	# type: ignore
-        'valuesBenchmark': [6],
-        'valuesTestParallelization': [*range(2, 4)],
-        'valuesTestValidation': [random.randint(2, 4)],
-    },
-    'A195646': {
-        'getMapShape': cast(Callable[[int], list[int]], lambda n: [3] * n), # type: ignore
-        'valuesBenchmark': [3],
-        'valuesTestParallelization': [*range(2, 3)],
-        'valuesTestValidation': [2],
-    },
-    'A001418': {
-        'getMapShape': cast(Callable[[int], list[int]], lambda n: [n, n]), # type: ignore
-        'valuesBenchmark': [5],
-        'valuesTestParallelization': [*range(2, 4)],
-        'valuesTestValidation': [random.randint(2, 4)],
-    },
+class SettingsOEIShardcodedValues(TypedDict):
+	getMapShape: Callable[[int], tuple[int, ...]]
+	valuesBenchmark: list[int]
+	valuesTestParallelization: list[int]
+	valuesTestValidation: list[int]
+
+settingsOEIShardcodedValues: dict[str, SettingsOEIShardcodedValues] = {
+	'A001415': {
+		'getMapShape': lambda n: (2, n) if n >= 2 else (n, 2),
+		'valuesBenchmark': [14],
+		'valuesTestParallelization': [*range(3, 7)],
+		'valuesTestValidation': [random.randint(2, 9)],
+	},
+	'A001416': {
+		'getMapShape': lambda n: (3, n) if n >= 3 else (n, 3),
+		'valuesBenchmark': [9],
+		'valuesTestParallelization': [*range(3, 5)],
+		'valuesTestValidation': [random.randint(2, 6)],
+	},
+	'A001417': {
+		'getMapShape': lambda n: tuple(2 for _dimension in range(n)),
+		'valuesBenchmark': [6],
+		'valuesTestParallelization': [*range(2, 4)],
+		'valuesTestValidation': [random.randint(2, 4)],
+	},
+	'A195646': {
+		'getMapShape': lambda n: tuple(3 for _dimension in range(n)),
+		'valuesBenchmark': [3],
+		'valuesTestParallelization': [*range(2, 3)],
+		'valuesTestValidation': [2],
+	},
+	'A001418': {
+		'getMapShape': lambda n: (n, n),
+		'valuesBenchmark': [5],
+		'valuesTestParallelization': [*range(2, 4)],
+		'valuesTestValidation': [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'."""
 
@@ -286,16 +293,16 @@ def oeisIDfor_n(oeisID: str, n: int | Any) -> int:
 	if not isinstance(n, int) or n < 0:
 		raise ValueError("`n` must be non-negative integer.")
 
-	listDimensions: list[int] = settingsOEIS[oeisID]['getMapShape'](n)
+	mapShape: tuple[int, ...] = settingsOEIS[oeisID]['getMapShape'](n)
 
-	if n <= 1 or len(listDimensions) < 2:
+	if n <= 1 or len(mapShape) < 2:
 		offset: int = settingsOEIS[oeisID]['offset']
 		if n < offset:
 			raise ArithmeticError(f"OEIS sequence {oeisID} is not defined at n={n}.")
 		foldsTotal: int = settingsOEIS[oeisID]['valuesKnown'][n]
 		return foldsTotal
-
-	return countFolds(listDimensions)
+	from mapFolding.basecamp import countFolds
+	return countFolds(mapShape)
 
 def OEIS_for_n() -> None:
 	"""Command-line interface for oeisIDfor_n."""