mapFolding 0.4.1__py3-none-any.whl → 0.4.3__py3-none-any.whl

mapFolding/__init__.py

@@ -11,6 +11,7 @@ from mapFolding.theSSOT import (
 
 # Datatype management
 from mapFolding.theSSOT import (
+	getDatatypeModule,
 	hackSSOTdatatype,
 	hackSSOTdtype,
 	setDatatypeElephino,
@@ -21,7 +22,7 @@ from mapFolding.theSSOT import (
 
 # Synthesize modules
 from mapFolding.theSSOT import (
-	formatModuleNameDEFAULT,
+	formatFilenameModuleDEFAULT,
 	getAlgorithmDispatcher,
 	getAlgorithmSource,
 	getPathJobRootDEFAULT,

mapFolding/basecamp.py

@@ -17,7 +17,7 @@ def countFolds(listDimensions: Sequence[int]
 		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: Datatype management.
+		**keywordArguments: Datatype management. See `outfitCountFolds` for details.
 	Returns:
 		foldsTotal: Total number of distinct ways to fold a map of the given dimensions.
 

mapFolding/beDRY.py

@@ -1,17 +1,20 @@
 """A relatively stable API for oft-needed functionality."""
 from mapFolding import (
 	computationState,
+	getDatatypeModule,
 	getPathJobRootDEFAULT,
+	hackSSOTdatatype,
 	hackSSOTdtype,
 	indexMy,
 	indexTrack,
 	setDatatypeElephino,
 	setDatatypeFoldsTotal,
 	setDatatypeLeavesTotal,
+	setDatatypeModule,
 )
-from numpy import integer
+from numpy import dtype, integer, ndarray
 from numpy.typing import DTypeLike, NDArray
-from typing import Any, List, Optional, Sequence, Tuple, Type, Union
+from typing import Any, List, Optional, Sequence, Tuple, Union
 from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
 import numba
 import numpy
@@ -19,24 +22,26 @@ import os
 import pathlib
 import sys
 
-def getFilenameFoldsTotal(mapShape: Union[Sequence[int], numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]]) -> str:
-	"""Make a standardized filename for the computed value `foldsTotal`.
+def getFilenameFoldsTotal(mapShape: Union[Sequence[int], ndarray[Tuple[int], dtype[integer[Any]]]]) -> str:
+	"""Imagine your computer has been counting folds for 70 hours, 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 across platforms
+		- safe filesystem characters
 		- 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
+		- 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 (e.g., [3, 2] for a 3x2 map)
+		mapShape: A sequence of integers representing the dimensions of the map.
 
 	Returns:
 		filenameFoldsTotal: A filename string in format 'pNxM.foldsTotal' where N,M are sorted dimensions
@@ -67,63 +72,65 @@ def getLeavesTotal(listDimensions: Sequence[int]) -> int:
 
 		return productDimensions
 
-def getPathFilenameFoldsTotal(mapShape: Union[Sequence[int], numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]], pathLikeWriteFoldsTotal: Optional[Union[str, os.PathLike[str]]] = None) -> pathlib.Path:
-	"""Get path for folds total file.
+def getPathFilenameFoldsTotal(mapShape: Union[Sequence[int], ndarray[Tuple[int], dtype[integer[Any]]]], pathLikeWriteFoldsTotal: Optional[Union[str, os.PathLike[str]]] = None) -> pathlib.Path:
+	"""Get a standardized path and filename for the computed value `foldsTotal`.
 
-	This function determines the file path for storing fold totals. If a path is provided,
-	it will use that path. If the path is a directory, it will append a default filename.
-	The function ensures the parent directory exists by creating it if necessary.
+	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 (Sequence[int]): List of dimensions for the map folding problem.
-		pathLikeWriteFoldsTotal (Union[str, os.PathLike[str]], optional): Path where to save
-			the folds total. Can be a file path or directory path. If None, uses default path.
+		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:
-		pathlib.Path: Complete path to the folds total file.
+		pathFilenameFoldsTotal: Absolute path and filename.
 	"""
-	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
+	pathLikeSherpa = pathlib.Path(pathLikeWriteFoldsTotal) if pathLikeWriteFoldsTotal is not None else None
+	if not pathLikeSherpa:
+		pathLikeSherpa = getPathJobRootDEFAULT()
+	if pathLikeSherpa.is_dir():
+		pathFilenameFoldsTotal = pathLikeSherpa / getFilenameFoldsTotal(mapShape)
+	elif pathLikeSherpa.is_absolute():
+		pathFilenameFoldsTotal = pathLikeSherpa
 	else:
-		pathFilenameFoldsTotal = pathlib.Path(getPathJobRootDEFAULT(), pathLikeWriteFoldsTotal) # type: ignore
+		pathFilenameFoldsTotal = getPathJobRootDEFAULT() / pathLikeSherpa
 
 	pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
 	return pathFilenameFoldsTotal
 
 def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrencyLimit: int, CPUlimit: Optional[Union[bool, float, int]], listDimensions: Sequence[int]) -> int:
 	"""
-	Determines whether or how to divide the computation into tasks.
+	Determines whether to divide the computation into tasks and how many divisions.
 
 	Parameters
 	----------
-	computationDivisions (None):
+	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
+		- `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:
+	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
+		If computationDivisions is an unsupported type or if resulting task divisions exceed total leaves.
 
 	Notes
 	-----
-	Task divisions cannot exceed total leaves to prevent duplicate counting of folds.
+	Task divisions should not exceed total leaves or the folds will be over-counted.
 	"""
 	taskDivisions = 0
 	leavesTotal = getLeavesTotal(listDimensions)
@@ -133,9 +140,9 @@ def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrenc
 		taskDivisions = computationDivisions
 	elif isinstance(computationDivisions, str):
 		computationDivisions = computationDivisions.lower()
-		if computationDivisions == "maximum":
+		if computationDivisions == 'maximum':
 			taskDivisions = leavesTotal
-		elif computationDivisions == "cpu":
+		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.")
@@ -145,7 +152,7 @@ def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrenc
 
 	return taskDivisions
 
-def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optional[Type]) -> numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]]:
+def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optional[str]) -> ndarray[Tuple[int, int, int], dtype[integer[Any]]]:
 	"""
 	Constructs a multi-dimensional connection graph representing the connections between the leaves of a map with the given dimensions.
 	Also called a Cartesian product decomposition or dimensional product mapping.
@@ -157,21 +164,22 @@ def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optio
 	Returns
 		connectionGraph: A 3D numpy array with shape of (dimensionsTotal, leavesTotal + 1, leavesTotal + 1).
 	"""
-	if keywordArguments.get('datatype', None):
-		setDatatypeLeavesTotal(keywordArguments['datatype']) # type: ignore
-	datatype = hackSSOTdtype('connectionGraph')
+	ImaSetTheDatatype = keywordArguments.get('datatype', None)
+	if ImaSetTheDatatype:
+		setDatatypeLeavesTotal(ImaSetTheDatatype)
+	dtype = hackSSOTdtype('connectionGraph')
 	mapShape = validateListDimensions(listDimensions)
 	leavesTotal = getLeavesTotal(mapShape)
-	arrayDimensions = numpy.array(mapShape, dtype=datatype)
+	arrayDimensions = numpy.array(mapShape, dtype=dtype)
 	dimensionsTotal = len(arrayDimensions)
 
-	cumulativeProduct = numpy.multiply.accumulate([1] + mapShape, dtype=datatype)
-	coordinateSystem = numpy.zeros((dimensionsTotal, leavesTotal + 1), dtype=datatype)
+	cumulativeProduct = numpy.multiply.accumulate([1] + mapShape, dtype=dtype)
+	coordinateSystem = numpy.zeros((dimensionsTotal, leavesTotal + 1), dtype=dtype)
 	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=datatype)
+	connectionGraph = numpy.zeros((dimensionsTotal, leavesTotal + 1, leavesTotal + 1), dtype=dtype)
 	for indexDimension in range(dimensionsTotal):
 		for activeLeaf1ndex in range(1, leavesTotal + 1):
 			for connectee1ndex in range(1, activeLeaf1ndex + 1):
@@ -190,70 +198,68 @@ def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optio
 	return connectionGraph
 
 def makeDataContainer(shape: Union[int, Tuple[int, ...]], datatype: Optional[DTypeLike] = None) -> NDArray[integer[Any]]:
-	"""Create a zeroed-out `numpy.ndarray` with the given shape and datatype.
+	"""Create a zeroed-out `ndarray` with the given shape and datatype.
 
 	Parameters:
-		shape (Union[int, Tuple[int, ...]]): The shape of the array. Can be an integer for 1D arrays
+		shape: The shape of the array. Can be an integer for 1D arrays
 			or a tuple of integers for multi-dimensional arrays.
-		datatype (Optional[DTypeLike], optional): The desired data type for the array.
-			If None, defaults to dtypeLargeDEFAULT. Defaults to None.
+		datatype ('dtypeFoldsTotal'): The desired data type for the array.
+			If `None`, defaults to 'dtypeFoldsTotal'. Defaults to None.
 
 	Returns:
-		numpy.ndarray: A new array of given shape and type, filled with zeros.
+		dataContainer: A new array of given shape and type, filled with zeros.
+
+	Notes:
+		If a version of the algorithm were to use something other than numpy, such as JAX or CUDA, because other
+		functions use this function, it would be much easier to change the datatype "ecosystem".
 	"""
-	if datatype is None:
-		datatype = hackSSOTdtype('dtypeFoldsTotal')
-	return numpy.zeros(shape, dtype=datatype)
-
-def outfitCountFolds(listDimensions: Sequence[int]
-						, computationDivisions: Optional[Union[int, str]] = None
-						, CPUlimit: Optional[Union[bool, float, int]] = None
-						, **keywordArguments: Optional[Union[str, bool]]) -> computationState:
+	numpyDtype = datatype or hackSSOTdtype('dtypeFoldsTotal')
+	if 'numpy' == getDatatypeModule():
+		return numpy.zeros(shape, dtype=numpyDtype)
+	else:
+		raise NotImplementedError("Somebody done broke it.")
+
+def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, **keywordArguments: Optional[Union[str, bool]]) -> computationState:
 	"""
 	Initializes and configures the computation state for map folding computations.
 
-	Parameters
-	----------
-	listDimensions:
-		The dimensions of the map to be folded
-	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`
-	CPUlimit (None):
-		Whether and how to limit the CPU usage. See notes for details.
-	**keywordArguments:
-		Datatype management.
-
-	Returns
-	-------
-	computationState
-		An initialized computation state containing:
-		- connectionGraph: Graph representing connections in the map
-		- foldsSubTotals: Array tracking total folds
-		- mapShape: Validated and sorted dimensions of the map
-		- my: Array for internal state tracking
-		- gapsWhere: Array tracking gap positions
-		- the: Static settings and metadata
-		- track: Array for tracking computation progress
+	Parameters:
+		listDimensions: The dimensions of the map to be folded
+		computationDivisions (None): see `getTaskDivisions`
+		CPUlimit (None): see `setCPUlimit`
+		**keywordArguments: Datatype management, it's complicated: see the code below.
 
-	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.
+	Returns:
+		stateInitialized: The initialized computation state
 	"""
-	kwourGrapes = keywordArguments.get('sourGrapes', False)
-	kwatatype = keywordArguments.get('datatypeElephino', None)
-	if kwatatype: setDatatypeElephino(kwatatype, sourGrapes=kwourGrapes) # type: ignore
-	kwatatype = keywordArguments.get('datatypeFoldsTotal', None)
-	if kwatatype: setDatatypeFoldsTotal(kwatatype, sourGrapes=kwourGrapes) # type: ignore
-	kwatatype = keywordArguments.get('datatypeLeavesTotal', None)
-	if kwatatype: setDatatypeLeavesTotal(kwatatype, sourGrapes=kwourGrapes) # type: ignore
+	# keywordArguments START
+	kwourGrapes = keywordArguments.get('sourGrapes', None)
+	if kwourGrapes:
+		sourGrapes = True
+	else:
+		sourGrapes = False
+
+	ImaSetTheDatatype = keywordArguments.get('datatypeElephino', None)
+	if ImaSetTheDatatype:
+		ImaSetTheDatatype = str(ImaSetTheDatatype)
+		setDatatypeElephino(ImaSetTheDatatype, sourGrapes)
+
+	ImaSetTheDatatype = keywordArguments.get('datatypeFoldsTotal', None)
+	if ImaSetTheDatatype:
+		ImaSetTheDatatype = str(ImaSetTheDatatype)
+		setDatatypeFoldsTotal(ImaSetTheDatatype, sourGrapes)
+
+	ImaSetTheDatatype = keywordArguments.get('datatypeLeavesTotal', None)
+	if ImaSetTheDatatype:
+		ImaSetTheDatatype = str(ImaSetTheDatatype)
+		setDatatypeLeavesTotal(ImaSetTheDatatype, sourGrapes)
+
+	# NOTE well: this might be only hypothetical because as of this writing, `makeDataContainer` only makes numpy.zeros. But it's here in case things change.
+	ImaSetTheDatatype = keywordArguments.get('datatypeModule', None)
+	if ImaSetTheDatatype:
+		ImaSetTheDatatype = str(ImaSetTheDatatype)
+		setDatatypeModule(ImaSetTheDatatype, sourGrapes)
+	# keywordArguments END
 
 	my = makeDataContainer(len(indexMy), hackSSOTdtype('my'))
 
@@ -268,7 +274,7 @@ def outfitCountFolds(listDimensions: Sequence[int]
 	my[indexMy.dimensionsTotal] = len(mapShape)
 	my[indexMy.leaf1ndex] = 1
 	stateInitialized = computationState(
-		connectionGraph = makeConnectionGraph(mapShape, datatype=hackSSOTdtype('connectionGraph')),
+		connectionGraph = makeConnectionGraph(mapShape, datatype=hackSSOTdatatype('connectionGraph')),
 		foldGroups = foldGroups,
 		mapShape = numpy.array(mapShape, dtype=hackSSOTdtype('mapShape')),
 		my = my,
@@ -280,16 +286,16 @@ def outfitCountFolds(listDimensions: Sequence[int]
 
 def parseDimensions(dimensions: Sequence[int], parameterName: str = 'listDimensions') -> List[int]:
 	"""
-	Parse and validate dimensions are non-negative integers.
+	Parse and validate the dimensions are non-negative integers.
 
 	Parameters:
-		dimensions: Sequence of integers representing dimensions
-		parameterName ('listDimensions'): Name of the parameter for error messages. Defaults to 'listDimensions'
+		dimensions: Sequence of integers representing dimensions.
+		parameterName ('listDimensions'): Name of the parameter for error messages. Defaults to 'listDimensions'.
 	Returns:
-		listNonNegative: List of validated non-negative integers
+		listNonNegative: List of validated non-negative integers.
 	Raises:
-		ValueError: If any dimension is negative or if the list is empty
-		TypeError: If any element cannot be converted to integer (raised by intInnit)
+		ValueError: If any dimension is negative or if the list is empty.
+		TypeError: If any element cannot be converted to integer (raised by `intInnit`).
 	"""
 	listValidated = intInnit(dimensions, parameterName)
 	listNonNegative = []
@@ -350,6 +356,7 @@ def setCPUlimit(CPUlimit: Optional[Any]) -> int:
 
 	concurrencyLimit = int(defineConcurrencyLimit(CPUlimit))
 	numba.set_num_threads(concurrencyLimit)
+	concurrencyLimit = numba.get_num_threads()
 
 	return concurrencyLimit
 
@@ -364,7 +371,7 @@ def validateListDimensions(listDimensions: Sequence[int]) -> List[int]:
 		dimensionsValidSorted: A list, with at least two elements, of only positive integers.
 
 	Raises:
-		ValueError: If the input listDimensions is None.
+		ValueError: If the input listDimensions is empty.
 		NotImplementedError: If the resulting list of positive dimensions has fewer than two elements.
 	"""
 	if not listDimensions:

mapFolding/oeis.py

@@ -2,7 +2,7 @@
 _only_ things that implement _only_ the OEIS."""
 from datetime import datetime, timedelta
 from mapFolding import countFolds, getPathPackage
-from typing import Any, Callable, Dict, Final, List, Tuple, TYPE_CHECKING, Union
+from typing import Any, Callable, Dict, Final, List, Tuple, TYPE_CHECKING
 import argparse
 import pathlib
 import random
@@ -24,8 +24,8 @@ _pathCache = getPathPackage() / ".cache"
 
 class SettingsOEIS(TypedDict):
 	description: str
-	offset: int
 	getMapShape: Callable[[int], List[int]]
+	offset: int
 	valuesBenchmark: List[int]
 	valuesKnown: Dict[int, int]
 	valuesTestParallelization: List[int]
@@ -68,7 +68,7 @@ settingsOEIShardcodedValues: Dict[str, Dict[str, Any]] = {
 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) -> str:
+def validateOEISid(oeisIDcandidate: str) -> str:
 	"""
 	Validates an OEIS sequence ID against implemented sequences.
 
@@ -98,13 +98,14 @@ def _validateOEISid(oeisIDcandidate: str) -> str:
 				f"Available sequences:\n{_formatOEISsequenceInfo()}"
 			)
 
-def _getFilenameOEISbFile(oeisID: str) -> str:
-	oeisID = _validateOEISid(oeisID)
+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
@@ -133,7 +134,7 @@ def _parseBFileOEIS(OEISbFile: str, oeisID: str) -> Dict[int, int]:
 		OEISsequence[n] = aOFn
 	return OEISsequence
 
-def _getOEISofficial(pathFilenameCache: pathlib.Path, url: str) -> None | str:
+def getOEISofficial(pathFilenameCache: pathlib.Path, url: str) -> None | str:
 	cacheDays = 7
 	tryCache = False
 	if pathFilenameCache.exists():
@@ -158,7 +159,7 @@ def _getOEISofficial(pathFilenameCache: pathlib.Path, url: str) -> None | str:
 
 	return oeisInformation
 
-def _getOEISidValues(oeisID: str) -> Dict[int, int]:
+def getOEISidValues(oeisID: str) -> Dict[int, int]:
 	"""
 	Retrieves the specified OEIS sequence as a dictionary mapping integer indices
 	to their corresponding values.
@@ -177,21 +178,21 @@ def _getOEISidValues(oeisID: str) -> Dict[int, int]:
 		IOError: If there is an error reading from or writing to the local cache.
 	"""
 
-	pathFilenameCache = _pathCache / _getFilenameOEISbFile(oeisID)
-	url = f"https://oeis.org/{oeisID}/{_getFilenameOEISbFile(oeisID)}"
+	pathFilenameCache = _pathCache / getFilenameOEISbFile(oeisID)
+	url = f"https://oeis.org/{oeisID}/{getFilenameOEISbFile(oeisID)}"
 
-	oeisInformation = _getOEISofficial(pathFilenameCache, url)
+	oeisInformation = getOEISofficial(pathFilenameCache, url)
 
 	if oeisInformation:
 		return _parseBFileOEIS(oeisInformation, oeisID)
 	return {-1: -1}
 
-def _getOEISidInformation(oeisID: str) -> Tuple[str, int]:
-	oeisID = _validateOEISid(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)
+	oeisInformation = getOEISofficial(pathFilenameCache, url)
 
 	if not oeisInformation:
 		return "Not found", -1
@@ -221,8 +222,8 @@ def _getOEISidInformation(oeisID: str) -> Tuple[str, int]:
 def makeSettingsOEIS() -> Dict[str, SettingsOEIS]:
 	settingsTarget = {}
 	for oeisID in oeisIDsImplemented:
-		valuesKnownSherpa = _getOEISidValues(oeisID)
-		descriptionSherpa, offsetSherpa = _getOEISidInformation(oeisID)
+		valuesKnownSherpa = getOEISidValues(oeisID)
+		descriptionSherpa, offsetSherpa = getOEISidInformation(oeisID)
 		settingsTarget[oeisID] = SettingsOEIS(
 			description=descriptionSherpa,
 			offset=offsetSherpa,
@@ -282,7 +283,7 @@ def oeisIDfor_n(oeisID: str, n: int) -> int:
 		ValueError: If n is negative.
 		KeyError: If the OEIS sequence ID is not directly implemented.
 	"""
-	oeisID = _validateOEISid(oeisID)
+	oeisID = validateOEISid(oeisID)
 
 	if not isinstance(n, int) or n < 0:
 		raise ValueError("`n` must be non-negative integer.")
@@ -328,7 +329,7 @@ def clearOEIScache() -> None:
 		return
 	for oeisID in settingsOEIS:
 		( _pathCache / f"{oeisID}.txt" ).unlink(missing_ok=True)
-		( _pathCache / _getFilenameOEISbFile(oeisID) ).unlink(missing_ok=True)
+		( _pathCache / getFilenameOEISbFile(oeisID) ).unlink(missing_ok=True)
 	print(f"Cache cleared from {_pathCache}")
 
 def getOEISids() -> None: