mapFolding 0.5.0__py3-none-any.whl → 0.6.0__py3-none-any.whl

mapFolding/__init__.py

@@ -1,69 +1,107 @@
+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',
+	'indexMy',
+	'indexTrack',
+	'myPackageNameIs',
+	'pathPackage',
+])
 
 # 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([
+	'additional_importsHARDCODED',
+	'formatFilenameModule',
+	'getAlgorithmDispatcher',
+	'getAlgorithmSource',
+	'getPathJobRootDEFAULT',
+	'getPathSyntheticModules',
+	'listCallablesDispatchees',
+	'moduleOfSyntheticModules',
+	'Z0Z_filenameModuleWrite',
+	'Z0Z_filenameWriteElseCallableTarget',
+	'Z0Z_getDatatypeModuleScalar',
+	'Z0Z_getDecoratorCallable',
+	'Z0Z_identifierCountFolds',
+	'Z0Z_setDatatypeModuleScalar',
+	'Z0Z_setDecoratorCallable',
+])
 
 # 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__: list[str] = [
-	'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 *

mapFolding/basecamp.py

@@ -3,11 +3,10 @@ from mapFolding import computationState, getDispatcherCallable, getPathFilenameF
 from os import PathLike
 from pathlib import Path
 
-def countFolds(listDimensions: Sequence[int],
-				pathLikeWriteFoldsTotal: str | PathLike[str] | None = None,
-				computationDivisions: int | str | None = None,
-				CPUlimit: int | float | bool | None = None,
-				**keywordArguments: str | bool
+def countFolds(listDimensions: Sequence[int]
+				, pathLikeWriteFoldsTotal: str | PathLike[str] | None = None
+				, computationDivisions: int | str | None = None
+				, CPUlimit: int | float | bool | None = None
 				) -> int:
 	"""Count the total number of possible foldings for a given map dimensions.
 
@@ -18,7 +17,6 @@ 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. See `outfitCountFolds` for details.
 	Returns:
 		foldsTotal: Total number of distinct ways to fold a map of the given dimensions.
 
@@ -39,7 +37,7 @@ 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, **keywordArguments)
+	stateUniversal: computationState = outfitCountFolds(listDimensions, computationDivisions=computationDivisions, CPUlimit=CPUlimit)
 
 	dispatcher = getDispatcherCallable()
 	dispatcher(**stateUniversal)

mapFolding/beDRY.py

@@ -7,13 +7,10 @@ from mapFolding import (
 	hackSSOTdtype,
 	indexMy,
 	indexTrack,
-	setDatatypeElephino,
-	setDatatypeFoldsTotal,
 	setDatatypeLeavesTotal,
-	setDatatypeModule,
 )
 from collections.abc import Sequence
-from numba import get_num_threads, set_num_threads
+from numba import get_num_threads, set_num_threads 
 from numpy import dtype, integer, ndarray
 from numpy.typing import DTypeLike, NDArray
 from pathlib import Path
@@ -24,7 +21,7 @@ import numpy
 import os
 
 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,
+	"""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`.
@@ -45,7 +42,7 @@ def getFilenameFoldsTotal(mapShape: Sequence[int] | ndarray[tuple[int], dtype[in
 		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
+		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'
 
@@ -139,7 +136,7 @@ def getTaskDivisions(computationDivisions: int | str | None, concurrencyLimit: i
 		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
@@ -220,7 +217,10 @@ def makeDataContainer(shape: int | tuple[int, ...], datatype: DTypeLike | None =
 	else:
 		raise NotImplementedError("Somebody done broke it.")
 
-def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: int | str | None = None, CPUlimit: bool | float | int | None = None, **keywordArguments: str | bool | None) -> computationState:
+def outfitCountFolds(listDimensions: Sequence[int]
+					, computationDivisions: int | str | None = None
+					, CPUlimit: bool | float | int | None = None
+					) -> computationState:
 	"""
 	Initializes and configures the computation state for map folding computations.
 
@@ -228,40 +228,10 @@ def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: int |
 		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.
 
 	Returns:
 		stateInitialized: The initialized computation state
 	"""
-	# 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'))
 
 	mapShape = tuple(sorted(validateListDimensions(listDimensions)))
@@ -298,8 +268,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")
@@ -357,7 +327,7 @@ def setCPUlimit(CPUlimit: Any | None) -> int:
 
 	concurrencyLimit = int(defineConcurrencyLimit(CPUlimit))
 	set_num_threads(concurrencyLimit)
-	concurrencyLimit = get_num_threads()
+	concurrencyLimit: int = get_num_threads()
 
 	return concurrencyLimit
 

mapFolding/oeis.py

@@ -1,8 +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, getPathPackage
-from typing import Any, Final, TYPE_CHECKING
+from mapFolding import countFolds, pathPackage
+from pathlib import Path
+from typing import Any, cast, Final, TYPE_CHECKING
 import argparse
 import pathlib
 import random
@@ -22,7 +23,7 @@ cacheDays = 7
 """
 Section: make `settingsOEIS`"""
 
-_pathCache = getPathPackage() / ".cache"
+pathCache: Path = pathPackage / ".cache"
 
 class SettingsOEIS(TypedDict):
 	description: str
@@ -35,38 +36,37 @@ class SettingsOEIS(TypedDict):
 	valueUnknown: int
 
 settingsOEIShardcodedValues: dict[str, dict[str, Any]] = {
-	'A001415': {
-		'getMapShape': lambda n: sorted([2, n]),
-		'valuesBenchmark': [14],
-		'valuesTestParallelization': [*range(3, 7)],
-		'valuesTestValidation': [random.randint(2, 9)],
-	},
-	'A001416': {
-		'getMapShape': lambda n: sorted([3, n]),
-		'valuesBenchmark': [9],
-		'valuesTestParallelization': [*range(3, 5)],
-		'valuesTestValidation': [random.randint(2, 6)],
-	},
-	'A001417': {
-		'getMapShape': lambda n: [2] * n,
-		'valuesBenchmark': [6],
-		'valuesTestParallelization': [*range(2, 4)],
-		'valuesTestValidation': [random.randint(2, 4)],
-	},
-	'A195646': {
-		'getMapShape': lambda n: [3] * 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)],
-	},
+    '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)],
+    },
 }
-
 oeisIDsImplemented: Final[list[str]]  = sorted([oeisID.upper().strip() for oeisID in settingsOEIShardcodedValues.keys()])
 """Directly implemented OEIS IDs; standardized, e.g., 'A001415'."""
 
@@ -91,7 +91,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:
@@ -123,12 +123,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
@@ -139,10 +139,10 @@ def _parseBFileOEIS(OEISbFile: str, oeisID: str) -> dict[int, int]:
 def getOEISofficial(pathFilenameCache: pathlib.Path, url: str) -> None | str:
 	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()
@@ -179,10 +179,10 @@ 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)
@@ -190,40 +190,37 @@ def getOEISidValues(oeisID: str) -> dict[int, 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 = []
+	listDescriptionDeconstructed: list[str] = []
 	offset = None
-	for line in oeisInformation.splitlines():
-		if line.startswith('%N'):
-			parts = line.split()
-			if parts[1] == oeisID:
-				desc_part = ' '.join(parts[2:])
-				description_parts.append(desc_part)
-		elif line.startswith('%O'):
-			parts = line.split()
-			if parts[1] == oeisID:
-				offset_str = parts[2].split(',')[0]
-				offset = int(offset_str)
-	if not description_parts:
+	for ImaStr in oeisInformation.splitlines():
+		ImaStr = ImaStr.strip() + "I am writing code to string parse machine readable data because in 2025, people can't even spell enteroperableity."
+		secretCode, title, secretData =ImaStr.split(maxsplit=2)
+		if secretCode == '%N' and title == oeisID:
+			listDescriptionDeconstructed.append(secretData)
+		if secretCode == '%O' and title == oeisID:
+			offsetAsStr: str = secretData.split(',')[0]
+			offset = int(offsetAsStr)
+	if not listDescriptionDeconstructed:
 		warnings.warn(f"No description found for {oeisID}")
-		description_parts.append("No description found")
+		listDescriptionDeconstructed.append("No description found")
 	if offset is None:
 		warnings.warn(f"No offset found for {oeisID}")
 		offset = -1
-	description = ' '.join(description_parts)
+	description: str = ' '.join(listDescriptionDeconstructed)
 	return description, offset
 
 def makeSettingsOEIS() -> dict[str, SettingsOEIS]:
-	settingsTarget = {}
+	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,
@@ -245,8 +242,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"
@@ -269,7 +266,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).
 
@@ -292,10 +289,10 @@ def oeisIDfor_n(oeisID: str, n: int) -> int:
 	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)
@@ -320,18 +317,18 @@ 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:
 	"""Delete all cached OEIS sequence files."""
-	if not _pathCache.exists():
-		print(f"Cache directory, {_pathCache}, not found - nothing to clear.")
+	if not pathCache.exists():
+		print(f"Cache directory, {pathCache}, not found - nothing to clear.")
 		return
 	for oeisID in settingsOEIS:
-		( _pathCache / f"{oeisID}.txt" ).unlink(missing_ok=True)
-		( _pathCache / getFilenameOEISbFile(oeisID) ).unlink(missing_ok=True)
-	print(f"Cache cleared from {_pathCache}")
+		( pathCache / f"{oeisID}.txt" ).unlink(missing_ok=True)
+		( pathCache / getFilenameOEISbFile(oeisID) ).unlink(missing_ok=True)
+	print(f"Cache cleared from {pathCache}")
 
 def getOEISids() -> None:
 	"""Print all available OEIS sequence IDs that are directly implemented."""

mapFolding/theConfiguration.py

@@ -0,0 +1,58 @@
+from types import ModuleType
+from mapFolding.theWrongWay import *
+from sys import modules as sysModules
+from pathlib import Path
+from importlib import import_module as importlib_import_module
+from inspect import getfile as inspect_getfile
+from typing import Final
+"""
+evaluateWhenPACKAGING
+evaluateWhenINSTALLING
+"""
+try:
+	import tomli
+	TRYmyPackageNameIs: str = tomli.load(Path("../pyproject.toml").open('rb'))["project"]["name"]
+except Exception:
+	TRYmyPackageNameIs: str = myPackageNameIsPACKAGING
+
+myPackageNameIs: Final[str] = TRYmyPackageNameIs
+
+def getPathPackageINSTALLING() -> Path:
+	pathPackage = Path(inspect_getfile(importlib_import_module(myPackageNameIs)))
+	if pathPackage.is_file():
+		pathPackage: Path = pathPackage.parent
+	return pathPackage
+
+pathPackage: Path = getPathPackageINSTALLING()
+
+moduleOfSyntheticModules: Final[str] = "syntheticModules"
+formatNameModule = "numba_{callableTarget}"
+formatFilenameModule = formatNameModule + ".py"
+dispatcherCallableName = "doTheNeedful"
+nameModuleDispatcher: str = formatNameModule.format(callableTarget=dispatcherCallableName)
+Z0Z_filenameModuleWrite = 'numbaCount.py'
+Z0Z_filenameWriteElseCallableTarget: str = 'count'
+
+def getDispatcherCallable():
+    logicalPathModule: str = f"{myPackageNameIs}.{moduleOfSyntheticModules}.{nameModuleDispatcher}"
+    moduleImported: ModuleType = importlib_import_module(logicalPathModule)
+    return getattr(moduleImported, dispatcherCallableName)
+
+def getAlgorithmSource() -> ModuleType:
+	logicalPathModule: str = f"{myPackageNameIs}.{algorithmSourcePACKAGING}"
+	moduleImported: ModuleType = importlib_import_module(logicalPathModule)
+	return moduleImported
+	# from mapFolding import theDao
+	# return theDao
+
+# TODO learn how to see this from the user's perspective
+def getPathJobRootDEFAULT() -> Path:
+	if 'google.colab' in sysModules:
+		pathJobDEFAULT: Path = Path("/content/drive/MyDrive") / "jobs"
+	else:
+		pathJobDEFAULT = pathPackage / "jobs"
+	return pathJobDEFAULT
+
+listCallablesDispatchees: list[str] = listCallablesDispatcheesHARDCODED
+
+additional_importsHARDCODED.append(myPackageNameIs)

mapFolding/theDao.py

@@ -147,7 +147,7 @@ def countParallel(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[A
 
 	taskDivisionsPrange = myPARALLEL[indexMy.taskDivisions.value]
 
-	for indexSherpa in prange(taskDivisionsPrange):
+	for indexSherpa in prange(taskDivisionsPrange): # type: ignore
 		groupsOfFolds: int = 0
 
 		gapsWhere = gapsWherePARALLEL.copy()