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

mapFolding/__init__.py

@@ -1,69 +1,104 @@
+from collections import defaultdict
+from types import ModuleType
+import importlib
+
+_dictionaryListsImportFrom: dict[str, list[str]] = defaultdict(list)
+
+def __getattr__(name: str):
+	if name not in _mapSymbolToModule:
+		raise AttributeError(f"module '{__name__}' has no attribute '{name}'")
+
+	try:
+		moduleAsStr: str = _mapSymbolToModule[name]
+		module: ModuleType =  importlib.import_module(moduleAsStr)
+		blankSymbol = getattr(module, name)
+	except (ImportError, ModuleNotFoundError, AttributeError):
+		raise
+
+	# The need to inject into globals tells us that the symbol has not actually been imported
+	globals()[name] = blankSymbol
+	return blankSymbol
+
+_dictionaryListsImportFrom['mapFolding.basecamp'].extend([
+	'countFolds',
+])
+
+_dictionaryListsImportFrom['mapFolding.beDRY'].extend([
+	'getFilenameFoldsTotal',
+	'getPathFilenameFoldsTotal',
+	'outfitCountFolds',
+	'saveFoldsTotal',
+])
+
+_dictionaryListsImportFrom['mapFolding.oeis'].extend([
+	'clearOEIScache',
+	'getOEISids',
+	'oeisIDfor_n',
+])
+
 # fundamentals
-from mapFolding.theSSOT import (
-	computationState,
-	EnumIndices,
-	getDispatcherCallable,
-	getPathPackage,
-	indexMy,
-	indexTrack,
-	myPackageNameIs,
-)
+_dictionaryListsImportFrom['mapFolding.theSSOT'].extend([
+	'computationState',
+	'EnumIndices',
+	'getDispatcherCallable',
+	'getPathPackage',
+	'indexMy',
+	'indexTrack',
+	'myPackageNameIs',
+])
 
 # Datatype management
-from mapFolding.theSSOT import (
-	getDatatypeModule,
-	hackSSOTdatatype,
-	hackSSOTdtype,
-	setDatatypeElephino,
-	setDatatypeFoldsTotal,
-	setDatatypeLeavesTotal,
-	setDatatypeModule,
-)
+_dictionaryListsImportFrom['mapFolding.theSSOT'].extend([
+	'getDatatypeModule',
+	'hackSSOTdatatype',
+	'hackSSOTdtype',
+	'setDatatypeElephino',
+	'setDatatypeFoldsTotal',
+	'setDatatypeLeavesTotal',
+	'setDatatypeModule',
+])
 
 # Synthesize modules
-from mapFolding.theSSOT import (
-	formatFilenameModuleDEFAULT,
-	getAlgorithmDispatcher,
-	getAlgorithmSource,
-	getPathJobRootDEFAULT,
-	getPathSyntheticModules,
-	moduleOfSyntheticModules,
-	Z0Z_getDatatypeModuleScalar,
-	Z0Z_getDecoratorCallable,
-	Z0Z_setDatatypeModuleScalar,
-	Z0Z_setDecoratorCallable,
-	Z0Z_identifierCountFolds,
-)
+_dictionaryListsImportFrom['mapFolding.theSSOT'].extend([
+	'formatFilenameModuleDEFAULT',
+	'getAlgorithmDispatcher',
+	'getAlgorithmSource',
+	'getPathJobRootDEFAULT',
+	'getPathSyntheticModules',
+	'moduleOfSyntheticModules',
+	'Z0Z_getDatatypeModuleScalar',
+	'Z0Z_getDecoratorCallable',
+	'Z0Z_setDatatypeModuleScalar',
+	'Z0Z_setDecoratorCallable',
+	'Z0Z_identifierCountFolds',
+])
 
 # Parameters for the prima donna
-from mapFolding.theSSOT import (
-	ParametersNumba,
-	parametersNumbaDEFAULT,
-	parametersNumbaFailEarly,
-	parametersNumbaMinimum,
-	parametersNumbaParallelDEFAULT,
-	parametersNumbaSuperJit,
-	parametersNumbaSuperJitParallel,
-)
+_dictionaryListsImportFrom['mapFolding.theSSOT'].extend([
+	'ParametersNumba',
+	'parametersNumbaDEFAULT',
+	'parametersNumbaFailEarly',
+	'parametersNumbaMinimum',
+	'parametersNumbaParallelDEFAULT',
+	'parametersNumbaSuperJit',
+	'parametersNumbaSuperJitParallel',
+])
 
 # Coping
-from mapFolding.theSSOT import (
-	FREAKOUT,
-)
-
-from mapFolding.beDRY import (
-	getFilenameFoldsTotal,
-	getPathFilenameFoldsTotal,
-	outfitCountFolds,
-	saveFoldsTotal,
-)
+_dictionaryListsImportFrom['mapFolding.theSSOT'].extend([
+	'FREAKOUT',
+])
 
-from mapFolding.basecamp import countFolds
-from mapFolding.oeis import clearOEIScache, getOEISids, oeisIDfor_n
+_mapSymbolToModule: dict[str, str] = {}
+for moduleAsStr, listSymbolsAsStr in _dictionaryListsImportFrom.items():
+	for symbolAsStr in listSymbolsAsStr:
+		_mapSymbolToModule[symbolAsStr] = moduleAsStr
 
-__all__ = [
-	'clearOEIScache',
-	'countFolds',
-	'getOEISids',
-	'oeisIDfor_n',
-]
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+	from basecamp import *
+	from beDRY import *
+	from oeis import *
+	from theDao import *
+	from theSSOT import *
+	from theSSOTdatatypes import *

mapFolding/basecamp.py

@@ -1,12 +1,13 @@
+from collections.abc import Sequence
 from mapFolding import computationState, getDispatcherCallable, getPathFilenameFoldsTotal, outfitCountFolds, saveFoldsTotal
-from typing import Optional, Sequence, Union
-import os
+from os import PathLike
+from pathlib import Path
 
 def countFolds(listDimensions: Sequence[int]
-				, pathLikeWriteFoldsTotal: Optional[Union[str, os.PathLike[str]]] = None
-				, computationDivisions: Optional[Union[int, str]] = None
-				, CPUlimit: Optional[Union[int, float, bool]] = None
-				, **keywordArguments: Optional[Union[str, bool]]
+				, pathLikeWriteFoldsTotal: str | PathLike[str] | None = None
+				, computationDivisions: int | str | None = None
+				, CPUlimit: int | float | bool | None = None
+				, **keywordArguments: str | bool
 				) -> int:
 	"""Count the total number of possible foldings for a given map dimensions.
 
@@ -40,16 +41,13 @@ def countFolds(listDimensions: Sequence[int]
 	"""
 	stateUniversal: computationState = outfitCountFolds(listDimensions, computationDivisions=computationDivisions, CPUlimit=CPUlimit, **keywordArguments)
 
-	pathFilenameFoldsTotal = None
-	if pathLikeWriteFoldsTotal is not None:
-		pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateUniversal['mapShape'], pathLikeWriteFoldsTotal)
-
 	dispatcher = getDispatcherCallable()
 	dispatcher(**stateUniversal)
 
 	foldsTotal = int(stateUniversal['foldGroups'][0:-1].sum() * stateUniversal['foldGroups'][-1])
 
-	if pathFilenameFoldsTotal is not None:
+	if pathLikeWriteFoldsTotal is not None:
+		pathFilenameFoldsTotal: Path = getPathFilenameFoldsTotal(stateUniversal['mapShape'], pathLikeWriteFoldsTotal)
 		saveFoldsTotal(pathFilenameFoldsTotal, foldsTotal)
 
 	return foldsTotal

mapFolding/beDRY.py

@@ -12,17 +12,18 @@ from mapFolding import (
 	setDatatypeLeavesTotal,
 	setDatatypeModule,
 )
+from collections.abc import Sequence
+from numba import get_num_threads, set_num_threads # type: ignore
 from numpy import dtype, integer, ndarray
 from numpy.typing import DTypeLike, NDArray
-from typing import Any, List, Optional, Sequence, Tuple, Union
+from pathlib import Path
+from sys import maxsize as sysMaxsize
+from typing import Any
 from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
-import numba
 import numpy
 import os
-import pathlib
-import sys
 
-def getFilenameFoldsTotal(mapShape: Union[Sequence[int], ndarray[Tuple[int], dtype[integer[Any]]]]) -> str:
+def getFilenameFoldsTotal(mapShape: 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.
 
@@ -66,13 +67,13 @@ def getLeavesTotal(listDimensions: Sequence[int]) -> int:
 	else:
 		productDimensions = 1
 		for dimension in listPositive:
-			if dimension > sys.maxsize // productDimensions:
+			if dimension > sysMaxsize // productDimensions:
 				raise OverflowError(f"I received {dimension=} in {listDimensions=}, but the product of the dimensions exceeds the maximum size of an integer on this system.")
 			productDimensions *= dimension
 
 		return productDimensions
 
-def getPathFilenameFoldsTotal(mapShape: Union[Sequence[int], ndarray[Tuple[int], dtype[integer[Any]]]], pathLikeWriteFoldsTotal: Optional[Union[str, os.PathLike[str]]] = None) -> pathlib.Path:
+def getPathFilenameFoldsTotal(mapShape: Sequence[int] | ndarray[tuple[int], dtype[integer[Any]]], 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
@@ -86,7 +87,7 @@ def getPathFilenameFoldsTotal(mapShape: Union[Sequence[int], ndarray[Tuple[int],
 	Returns:
 		pathFilenameFoldsTotal: Absolute path and filename.
 	"""
-	pathLikeSherpa = pathlib.Path(pathLikeWriteFoldsTotal) if pathLikeWriteFoldsTotal is not None else None
+	pathLikeSherpa = Path(pathLikeWriteFoldsTotal) if pathLikeWriteFoldsTotal is not None else None
 	if not pathLikeSherpa:
 		pathLikeSherpa = getPathJobRootDEFAULT()
 	if pathLikeSherpa.is_dir():
@@ -99,7 +100,7 @@ def getPathFilenameFoldsTotal(mapShape: Union[Sequence[int], ndarray[Tuple[int],
 	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:
+def getTaskDivisions(computationDivisions: int | str | None, concurrencyLimit: int, CPUlimit: bool | float | int | None, listDimensions: Sequence[int]) -> int:
 	"""
 	Determines whether to divide the computation into tasks and how many divisions.
 
@@ -138,7 +139,7 @@ def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrenc
 		pass
 	elif isinstance(computationDivisions, int):
 		taskDivisions = computationDivisions
-	elif isinstance(computationDivisions, str):
+	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
@@ -152,7 +153,7 @@ def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrenc
 
 	return taskDivisions
 
-def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optional[str]) -> ndarray[Tuple[int, int, int], dtype[integer[Any]]]:
+def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: str | None) -> 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.
@@ -179,7 +180,7 @@ def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optio
 		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=dtype)
+	connectionGraph: ndarray[tuple[int, int, int], numpy.dtype[integer[Any]]] = 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):
@@ -197,7 +198,7 @@ def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optio
 
 	return connectionGraph
 
-def makeDataContainer(shape: Union[int, Tuple[int, ...]], datatype: Optional[DTypeLike] = None) -> NDArray[integer[Any]]:
+def makeDataContainer(shape: int | tuple[int, ...], datatype: DTypeLike | None = None) -> NDArray[integer[Any]]:
 	"""Create a zeroed-out `ndarray` with the given shape and datatype.
 
 	Parameters:
@@ -219,7 +220,7 @@ def makeDataContainer(shape: Union[int, Tuple[int, ...]], datatype: Optional[DTy
 	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:
+def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: int | str | None = None, CPUlimit: bool | float | int | None = None, **keywordArguments: str | bool | None) -> computationState:
 	"""
 	Initializes and configures the computation state for map folding computations.
 
@@ -284,7 +285,7 @@ def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: Option
 
 	return stateInitialized
 
-def parseDimensions(dimensions: Sequence[int], parameterName: str = 'listDimensions') -> List[int]:
+def parseDimensions(dimensions: Sequence[int], parameterName: str = 'listDimensions') -> list[int]:
 	"""
 	Parse and validate the dimensions are non-negative integers.
 
@@ -297,8 +298,8 @@ def parseDimensions(dimensions: Sequence[int], parameterName: str = 'listDimensi
 		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 = []
+	listValidated: list[int] = intInnit(dimensions, parameterName)
+	listNonNegative: list[int] = []
 	for dimension in listValidated:
 		if dimension < 0:
 			raise ValueError(f"Dimension {dimension} must be non-negative")
@@ -306,7 +307,7 @@ def parseDimensions(dimensions: Sequence[int], parameterName: str = 'listDimensi
 
 	return listNonNegative
 
-def saveFoldsTotal(pathFilename: Union[str, os.PathLike[str]], foldsTotal: int) -> None:
+def saveFoldsTotal(pathFilename: str | os.PathLike[str], foldsTotal: int) -> None:
 	"""
 	Save foldsTotal with multiple fallback mechanisms.
 
@@ -315,7 +316,7 @@ def saveFoldsTotal(pathFilename: Union[str, os.PathLike[str]], foldsTotal: int)
 		foldsTotal: Critical computed value to save
 	"""
 	try:
-		pathFilenameFoldsTotal = pathlib.Path(pathFilename)
+		pathFilenameFoldsTotal = Path(pathFilename)
 		pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
 		pathFilenameFoldsTotal.write_text(str(foldsTotal))
 	except Exception as ERRORmessage:
@@ -333,7 +334,7 @@ def saveFoldsTotal(pathFilename: Union[str, os.PathLike[str]], foldsTotal: int)
 		except Exception:
 			print(foldsTotal)
 
-def setCPUlimit(CPUlimit: Optional[Any]) -> int:
+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:
@@ -355,12 +356,12 @@ def setCPUlimit(CPUlimit: Optional[Any]) -> int:
 		CPUlimit = oopsieKwargsie(CPUlimit)
 
 	concurrencyLimit = int(defineConcurrencyLimit(CPUlimit))
-	numba.set_num_threads(concurrencyLimit)
-	concurrencyLimit = numba.get_num_threads()
+	set_num_threads(concurrencyLimit)
+	concurrencyLimit: int = get_num_threads()
 
 	return concurrencyLimit
 
-def validateListDimensions(listDimensions: Sequence[int]) -> List[int]:
+def validateListDimensions(listDimensions: Sequence[int]) -> list[int]:
 	"""
 	Validates and sorts a sequence of at least two positive dimensions.
 

mapFolding/oeis.py

@@ -1,10 +1,11 @@
-"""Everything implementing the The Online Encyclopedia of Integer Sequences (OEIS);
-_only_ things that implement _only_ the OEIS."""
+"""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, getPathPackage
-from typing import Any, Callable, Dict, Final, List, Tuple, TYPE_CHECKING
+from typing import Any, Final, TYPE_CHECKING
 import argparse
 import pathlib
+from pathlib import Path
 import random
 import sys
 import time
@@ -17,22 +18,24 @@ if TYPE_CHECKING:
 else:
 	TypedDict = dict
 
+cacheDays = 7
+
 """
 Section: make `settingsOEIS`"""
 
-_pathCache = getPathPackage() / ".cache"
+_pathCache: Path = getPathPackage() / ".cache"
 
 class SettingsOEIS(TypedDict):
 	description: str
-	getMapShape: Callable[[int], List[int]]
+	getMapShape: Callable[[int], list[int]]
 	offset: int
-	valuesBenchmark: List[int]
-	valuesKnown: Dict[int, int]
-	valuesTestParallelization: List[int]
-	valuesTestValidation: List[int]
+	valuesBenchmark: list[int]
+	valuesKnown: dict[int, int]
+	valuesTestParallelization: list[int]
+	valuesTestValidation: list[int]
 	valueUnknown: int
 
-settingsOEIShardcodedValues: Dict[str, Dict[str, Any]] = {
+settingsOEIShardcodedValues: dict[str, dict[str, Any]] = {
 	'A001415': {
 		'getMapShape': lambda n: sorted([2, n]),
 		'valuesBenchmark': [14],
@@ -65,7 +68,7 @@ settingsOEIShardcodedValues: Dict[str, Dict[str, Any]] = {
 	},
 }
 
-oeisIDsImplemented: Final[List[str]]  = sorted([oeisID.upper().strip() for oeisID in settingsOEIShardcodedValues.keys()])
+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:
@@ -89,7 +92,7 @@ def validateOEISid(oeisIDcandidate: str) -> str:
 	if oeisIDcandidate in oeisIDsImplemented:
 		return oeisIDcandidate
 	else:
-		oeisIDcleaned = str(oeisIDcandidate).upper().strip()
+		oeisIDcleaned: str = str(oeisIDcandidate).upper().strip()
 		if oeisIDcleaned in oeisIDsImplemented:
 			return oeisIDcleaned
 		else:
@@ -102,7 +105,7 @@ def getFilenameOEISbFile(oeisID: str) -> str:
 	oeisID = validateOEISid(oeisID)
 	return f"b{oeisID[1:]}.txt"
 
-def _parseBFileOEIS(OEISbFile: str, oeisID: str) -> Dict[int, int]:
+def _parseBFileOEIS(OEISbFile: str, oeisID: str) -> dict[int, int]:
 	"""
 	Parses the content of an OEIS b-file for a given sequence ID.
 
@@ -121,12 +124,12 @@ def _parseBFileOEIS(OEISbFile: str, oeisID: str) -> Dict[int, int]:
 		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()
+	bFileLines: list[str] = OEISbFile.strip().splitlines()
 	if not bFileLines.pop(0).startswith(f"# {oeisID}"):
 		warnings.warn(f"Content does not match sequence {oeisID}")
 		return {-1: -1}
 
-	OEISsequence = {}
+	OEISsequence: dict[int, int] = {}
 	for line in bFileLines:
 		if line.startswith('#'):
 			continue
@@ -135,17 +138,16 @@ def _parseBFileOEIS(OEISbFile: str, oeisID: str) -> Dict[int, int]:
 	return OEISsequence
 
 def getOEISofficial(pathFilenameCache: pathlib.Path, url: str) -> None | str:
-	cacheDays = 7
 	tryCache = False
 	if pathFilenameCache.exists():
-		fileAge = datetime.now() - datetime.fromtimestamp(pathFilenameCache.stat().st_mtime)
-		tryCache = fileAge < timedelta(days=cacheDays)
+		fileAge: timedelta = datetime.now() - datetime.fromtimestamp(pathFilenameCache.stat().st_mtime)
+		tryCache: bool = fileAge < timedelta(days=cacheDays)
 
-	oeisInformation = None
+	oeisInformation: str | None = None
 	if tryCache:
 		try:
 			oeisInformation = pathFilenameCache.read_text()
-		except IOError:
+		except OSError:
 			tryCache = False
 
 	if not tryCache:
@@ -159,7 +161,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.
@@ -178,26 +180,26 @@ 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: Path = _pathCache / getFilenameOEISbFile(oeisID)
+	url: str = f"https://oeis.org/{oeisID}/{getFilenameOEISbFile(oeisID)}"
 
-	oeisInformation = getOEISofficial(pathFilenameCache, url)
+	oeisInformation: None | str = getOEISofficial(pathFilenameCache, url)
 
 	if oeisInformation:
 		return _parseBFileOEIS(oeisInformation, oeisID)
 	return {-1: -1}
 
-def getOEISidInformation(oeisID: str) -> Tuple[str, int]:
+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"
+	pathFilenameCache: Path = _pathCache / f"{oeisID}.txt"
+	url: str = f"https://oeis.org/search?q=id:{oeisID}&fmt=text"
 
-	oeisInformation = getOEISofficial(pathFilenameCache, url)
+	oeisInformation: None | str = getOEISofficial(pathFilenameCache, url)
 
 	if not oeisInformation:
 		return "Not found", -1
 
-	description_parts = []
+	description_parts: list[str] = []
 	offset = None
 	for line in oeisInformation.splitlines():
 		if line.startswith('%N'):
@@ -206,9 +208,9 @@ def getOEISidInformation(oeisID: str) -> Tuple[str, int]:
 				desc_part = ' '.join(parts[2:])
 				description_parts.append(desc_part)
 		elif line.startswith('%O'):
-			parts = line.split()
+			parts: list[str] = line.split()
 			if parts[1] == oeisID:
-				offset_str = parts[2].split(',')[0]
+				offset_str: str = parts[2].split(',')[0]
 				offset = int(offset_str)
 	if not description_parts:
 		warnings.warn(f"No description found for {oeisID}")
@@ -216,13 +218,13 @@ def getOEISidInformation(oeisID: str) -> Tuple[str, int]:
 	if offset is None:
 		warnings.warn(f"No offset found for {oeisID}")
 		offset = -1
-	description = ' '.join(description_parts)
+	description: str = ' '.join(description_parts)
 	return description, offset
 
-def makeSettingsOEIS() -> Dict[str, SettingsOEIS]:
-	settingsTarget = {}
+def makeSettingsOEIS() -> dict[str, SettingsOEIS]:
+	settingsTarget: dict[str, SettingsOEIS] = {}
 	for oeisID in oeisIDsImplemented:
-		valuesKnownSherpa = getOEISidValues(oeisID)
+		valuesKnownSherpa: dict[int, int] = getOEISidValues(oeisID)
 		descriptionSherpa, offsetSherpa = getOEISidInformation(oeisID)
 		settingsTarget[oeisID] = SettingsOEIS(
 			description=descriptionSherpa,
@@ -236,7 +238,7 @@ def makeSettingsOEIS() -> Dict[str, SettingsOEIS]:
 		)
 	return settingsTarget
 
-settingsOEIS: Dict[str, SettingsOEIS] = makeSettingsOEIS()
+settingsOEIS: dict[str, SettingsOEIS] = makeSettingsOEIS()
 """All values and settings for `oeisIDsImplemented`."""
 
 """
@@ -244,8 +246,8 @@ Section: private functions"""
 
 def _formatHelpText() -> str:
 	"""Format standardized help text for both CLI and interactive use."""
-	exampleOEISid = oeisIDsImplemented[0]
-	exampleN = settingsOEIS[exampleOEISid]['valuesTestValidation'][-1]
+	exampleOEISid: str = oeisIDsImplemented[0]
+	exampleN: int = settingsOEIS[exampleOEISid]['valuesTestValidation'][-1]
 
 	return (
 		"\nAvailable OEIS sequences:\n"
@@ -268,7 +270,7 @@ def _formatOEISsequenceInfo() -> str:
 """
 Section: public functions"""
 
-def oeisIDfor_n(oeisID: str, n: int) -> int:
+def oeisIDfor_n(oeisID: str, n: int | Any) -> int:
 	"""
 	Calculate a(n) of a sequence from "The On-Line Encyclopedia of Integer Sequences" (OEIS).
 
@@ -288,13 +290,13 @@ def oeisIDfor_n(oeisID: str, n: int) -> int:
 	if not isinstance(n, int) or n < 0:
 		raise ValueError("`n` must be non-negative integer.")
 
-	listDimensions = settingsOEIS[oeisID]['getMapShape'](n)
+	listDimensions: list[int] = settingsOEIS[oeisID]['getMapShape'](n)
 
 	if n <= 1 or len(listDimensions) < 2:
-		offset = settingsOEIS[oeisID]['offset']
+		offset: int = settingsOEIS[oeisID]['offset']
 		if n < offset:
 			raise ArithmeticError(f"OEIS sequence {oeisID} is not defined at n={n}.")
-		foldsTotal = settingsOEIS[oeisID]['valuesKnown'][n]
+		foldsTotal: int = settingsOEIS[oeisID]['valuesKnown'][n]
 		return foldsTotal
 
 	return countFolds(listDimensions)
@@ -309,9 +311,9 @@ def OEIS_for_n() -> None:
 	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()
+	argumentsCLI: argparse.Namespace = parserCLI.parse_args()
 
-	timeStart = time.perf_counter()
+	timeStart: float = time.perf_counter()
 
 	try:
 		print(oeisIDfor_n(argumentsCLI.oeisID, argumentsCLI.n), "distinct folding patterns.")
@@ -319,7 +321,7 @@ def OEIS_for_n() -> None:
 		print(f"Error: {ERRORmessage}", file=sys.stderr)
 		sys.exit(1)
 
-	timeElapsed = time.perf_counter() - timeStart
+	timeElapsed: float = time.perf_counter() - timeStart
 	print(f"Time elapsed: {timeElapsed:.3f} seconds")
 
 def clearOEIScache() -> None: