mapFolding 0.13.1__py3-none-any.whl → 0.14.1__py3-none-any.whl

mapFolding/_oeisFormulas/A000136.py

@@ -0,0 +1,4 @@
+from mapFolding._oeisFormulas.A000682 import A000682
+
+def A000136(n: int) -> int:
+	return n * A000682(n)

mapFolding/_oeisFormulas/A000560.py

@@ -0,0 +1,4 @@
+from mapFolding._oeisFormulas.A000682 import A000682
+
+def A000560(n: int) -> int:
+    return A000682(n + 1) // 2

mapFolding/_oeisFormulas/A000682.py

@@ -0,0 +1,17 @@
+from mapFolding._oeisFormulas.matrixMeanders import count, curveMaximum
+
+def initializeA000682(n: int) -> dict[int, int]:
+	curveLocationsMAXIMUM = curveMaximum[n].curveLocationsMAXIMUM
+
+	curveSeed: int = 5 - (n & 0b1) * 4
+	listCurveLocations = [(curveSeed << 1) | curveSeed]
+
+	while listCurveLocations[-1] < curveLocationsMAXIMUM:
+		curveSeed = (curveSeed << 4) | 0b101
+		listCurveLocations.append((curveSeed << 1) | curveSeed)
+
+	return dict.fromkeys(listCurveLocations, 1)
+
+def A000682(n: int) -> int:
+	return count(n - 1, initializeA000682(n - 1))
+

mapFolding/_oeisFormulas/A005315.py

@@ -0,0 +1,4 @@
+from mapFolding._oeisFormulas.A005316 import A005316
+
+def A005315(n: int) -> int:
+	return A005316(2 * n - 1)

mapFolding/_oeisFormulas/A005316.py

@@ -0,0 +1,10 @@
+from mapFolding._oeisFormulas.matrixMeanders import count
+
+def initializeA005316(n: int) -> dict[int, int]:
+	if n & 0b1:
+		return {22: 1}
+	else:
+		return {15: 1}
+
+def A005316(n: int) -> int:
+	return count(n-1, initializeA005316(n-1))

mapFolding/_oeisFormulas/A223094.py

@@ -0,0 +1,7 @@
+from mapFolding._oeisFormulas.A000136 import A000136
+from mapFolding._oeisFormulas.A000682 import A000682
+
+def A223094(n: int) -> int:
+    return A000136(n) - A000682(n + 1)
+
+# %F A223094 For n >= 3: a(n) = n! - Sum_{k=3..n-1} (a(k)*n!/k!) - A000682(n+1). - _Roger Ford_, Aug 24 2024

mapFolding/_oeisFormulas/A259702.py

@@ -0,0 +1,4 @@
+from mapFolding._oeisFormulas.A000682 import A000682
+
+def A259702(n: int) -> int:
+	return A000682(n) // 2 - A000682(n - 1)

mapFolding/_oeisFormulas/A301620.py

@@ -0,0 +1,6 @@
+from mapFolding._oeisFormulas.A000682 import A000682
+
+def A301620(n: int) -> int:
+	return A000682(n + 2) - 2 * A000682(n + 1)
+
+# %F A301620 a(n) = Sum_{k=3..floor((n+3)/2)} (A259689(n+1,k)*(k-2)). - _Roger Ford_, Dec 10 2018

mapFolding/_oeisFormulas/Z0Z_aOFn.py

@@ -0,0 +1,18 @@
+from mapFolding._oeisFormulas.A000136 import A000136
+from mapFolding.oeis import dictionaryOEIS
+import sys
+import time
+
+# ruff: noqa: ERA001
+
+if __name__ == '__main__':
+	oeisID = 'A000136'
+	for n in range(3,30):
+
+		# print(n)
+
+		timeStart = time.perf_counter()
+		foldsTotal = A000136(n)
+		# sys.stdout.write(f"{n} {foldsTotal} {time.perf_counter() - timeStart:.2f}\n")
+		sys.stdout.write(f"{foldsTotal == dictionaryOEIS[oeisID]['valuesKnown'][n]} {n} {foldsTotal} {time.perf_counter() - timeStart:.2f}\n")
+

mapFolding/_oeisFormulas/Z0Z_oeisMeanders.py

@@ -0,0 +1,53 @@
+from mapFolding._oeisFormulas.A000560 import A000560
+from mapFolding._oeisFormulas.A000682 import A000682
+from mapFolding._oeisFormulas.A005315 import A005315
+from mapFolding._oeisFormulas.A005316 import A005316
+from mapFolding._oeisFormulas.A223094 import A223094
+from mapFolding._oeisFormulas.A259702 import A259702
+from mapFolding._oeisFormulas.A301620 import A301620
+from mapFolding.oeis import getOEISidInformation, getOEISidValues
+import sys
+
+oeisIDsMeanders: list[str] = [
+	'A000560',
+	'A000682',
+	'A005315',
+	'A005316',
+	'A223094',
+	'A259702',
+	'A301620',
+]
+
+dictionaryOEISMeanders: dict[str, dict[str, dict[int, int] | str | int]] = {
+	oeisID: {
+		'valuesKnown': getOEISidValues(oeisID),
+		'description': getOEISidInformation(oeisID)[0],
+		'offset': getOEISidInformation(oeisID)[1],
+	}
+	for oeisID in oeisIDsMeanders
+}
+
+# ruff: noqa: S101
+# pyright: reportIndexIssue=false
+
+rangeTest = range(5, 13)
+
+if __name__ == '__main__':
+	for n in rangeTest:
+
+		A000560for_n = A000560(n)
+		assert A000560for_n == dictionaryOEISMeanders['A000560']['valuesKnown'][n]
+		A000682for_n = A000682(n)
+		assert A000682for_n == dictionaryOEISMeanders['A000682']['valuesKnown'][n]
+		A005315for_n = A005315(n)
+		assert A005315for_n == dictionaryOEISMeanders['A005315']['valuesKnown'][n]
+		A005316for_n = A005316(n)
+		assert A005316for_n == dictionaryOEISMeanders['A005316']['valuesKnown'][n]
+		A223094for_n = A223094(n)
+		assert A223094for_n == dictionaryOEISMeanders['A223094']['valuesKnown'][n]
+		A259702for_n = A259702(n)
+		assert A259702for_n == dictionaryOEISMeanders['A259702']['valuesKnown'][n]
+		A301620for_n = A301620(n)
+		assert A301620for_n == dictionaryOEISMeanders['A301620']['valuesKnown'][n]
+
+	sys.stdout.write(f"\nTrue for {str(rangeTest)}\n")

mapFolding/_oeisFormulas/__init__.py

@@ -0,0 +1 @@
+"""OEIS formula collection and analysis."""

mapFolding/_oeisFormulas/matrixMeanders.py

@@ -0,0 +1,79 @@
+from mapFolding._oeisFormulas.matrixMeandersAnnex import curveMaximum as curveMaximum
+from typing import NamedTuple
+
+class BifurcatedCurves(NamedTuple):
+    bifurcationEven: int
+    bifurcationOdd: int
+    distinctCrossings: int
+    curveLocationsMAXIMUM: int
+
+dictionaryCurveLocations: dict[int, list[int]] = {}
+
+def getCurveLocations(bridges: int) -> list[BifurcatedCurves]:
+	global dictionaryCurveLocations  # noqa: PLW0603
+	curveLocationsMAXIMUM, bifurcationEvenLocator, bifurcationOddLocator = curveMaximum[bridges]
+	listBifurcatedCurves: list[BifurcatedCurves] = []
+	# TODO This is ready for concurrency and/or vectorization.
+	for curveLocations, listDistinctCrossings in dictionaryCurveLocations.items():
+		bifurcationEven = (curveLocations & bifurcationEvenLocator) >> 1
+		bifurcationOdd = (curveLocations & bifurcationOddLocator)
+		distinctCrossings = sum(listDistinctCrossings)
+		listBifurcatedCurves.append(BifurcatedCurves(bifurcationEven, bifurcationOdd, distinctCrossings, curveLocationsMAXIMUM))
+	dictionaryCurveLocations = {}
+	return listBifurcatedCurves
+
+def recordAnalysis(curveLocationAnalysis: int, curveLocationsMAXIMUM: int, distinctCrossings: int) -> None:
+	if curveLocationAnalysis < curveLocationsMAXIMUM:
+		dictionaryCurveLocations.setdefault(curveLocationAnalysis, []).append(distinctCrossings)
+
+def analyzeCurve(bifurcationEven: int, bifurcationOdd: int, distinctCrossings: int, curveLocationsMAXIMUM: int) -> None:
+	bifurcationEvenFinalZero = (bifurcationEven & 0b1) == 0
+	bifurcationEvenHasCurves = bifurcationEven != 1
+	bifurcationOddFinalZero = (bifurcationOdd & 0b1) == 0
+	bifurcationOddHasCurves = bifurcationOdd != 1
+
+	if bifurcationEvenHasCurves:
+		curveLocationAnalysis = (bifurcationEven >> 1) | (bifurcationOdd << 2) | bifurcationEvenFinalZero
+		recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
+
+	if bifurcationOddHasCurves:
+		curveLocationAnalysis = (bifurcationOdd >> 2) | (bifurcationEven << 3) | (bifurcationOddFinalZero << 1)
+		recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
+
+	curveLocationAnalysis = ((bifurcationOdd | (bifurcationEven << 1)) << 2) | 3
+	recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
+
+	if bifurcationEvenHasCurves and bifurcationOddHasCurves and (bifurcationEvenFinalZero or bifurcationOddFinalZero):
+		XOrHere2makePair = 0b1
+		findUnpairedBinary1 = 0
+
+		if bifurcationEvenFinalZero and not bifurcationOddFinalZero:
+			while findUnpairedBinary1 >= 0:
+				XOrHere2makePair <<= 2
+				findUnpairedBinary1 += 1 if (bifurcationEven & XOrHere2makePair) == 0 else -1
+			bifurcationEven ^= XOrHere2makePair
+
+		elif bifurcationOddFinalZero and not bifurcationEvenFinalZero:
+			while findUnpairedBinary1 >= 0:
+				XOrHere2makePair <<= 2
+				findUnpairedBinary1 += 1 if (bifurcationOdd & XOrHere2makePair) == 0 else -1
+			bifurcationOdd ^= XOrHere2makePair
+
+		curveLocationAnalysis = ((bifurcationEven >> 2) << 1) | (bifurcationOdd >> 2)
+		recordAnalysis(curveLocationAnalysis, curveLocationsMAXIMUM, distinctCrossings)
+
+def initializeCurveLocations(startingCurveLocations: dict[int, int]) -> None:
+	global dictionaryCurveLocations  # noqa: PLW0603
+	dictionaryCurveLocations = {curve: [distinctCrossings] for curve, distinctCrossings in startingCurveLocations.items()}
+
+def count(bridges: int, startingCurveLocations: dict[int, int]) -> int:
+	initializeCurveLocations(startingCurveLocations)
+
+	while bridges > 0:
+		bridges -= 1
+
+		# TODO This could be parallelized when `recordAnalysis` is thread-safe
+		for bifurcatedCurve in getCurveLocations(bridges):
+			analyzeCurve(*bifurcatedCurve)
+
+	return getCurveLocations(bridges)[0].distinctCrossings

mapFolding/_oeisFormulas/matrixMeandersAnnex.py

@@ -0,0 +1,84 @@
+from typing import NamedTuple
+import sys
+
+class limitLocators(NamedTuple):
+	curveLocationsMAXIMUM: int
+	bifurcationEvenLocator: int
+	bifurcationOddLocator: int
+
+curveMaximum: dict[int, limitLocators] = {
+0: limitLocators(16, 0x2a, 0x15),
+1: limitLocators(64, 0xaa, 0x55),
+2: limitLocators(256, 0x2aa, 0x155),
+3: limitLocators(1024, 0xaaa, 0x555),
+4: limitLocators(4096, 0x2aaa, 0x1555),
+5: limitLocators(16384, 0xaaaa, 0x5555),
+6: limitLocators(65536, 0x2aaaa, 0x15555),
+7: limitLocators(262144, 0xaaaaa, 0x55555),
+8: limitLocators(1048576, 0x2aaaaa, 0x155555),
+9: limitLocators(4194304, 0xaaaaaa, 0x555555),
+10: limitLocators(16777216, 0x2aaaaaa, 0x1555555),
+11: limitLocators(67108864, 0xaaaaaaa, 0x5555555),
+12: limitLocators(268435456, 0x2aaaaaaa, 0x15555555),
+13: limitLocators(1073741824, 0xaaaaaaaa, 0x55555555),
+14: limitLocators(4294967296, 0x2aaaaaaaa, 0x155555555),
+15: limitLocators(17179869184, 0xaaaaaaaaa, 0x555555555),
+16: limitLocators(68719476736, 0x2aaaaaaaaa, 0x1555555555),
+17: limitLocators(274877906944, 0xaaaaaaaaaa, 0x5555555555),
+18: limitLocators(1099511627776, 0x2aaaaaaaaaa, 0x15555555555),
+19: limitLocators(4398046511104, 0xaaaaaaaaaaa, 0x55555555555),
+20: limitLocators(17592186044416, 0x2aaaaaaaaaaa, 0x155555555555),
+21: limitLocators(70368744177664, 0xaaaaaaaaaaaa, 0x555555555555),
+22: limitLocators(281474976710656, 0x2aaaaaaaaaaaa, 0x1555555555555),
+23: limitLocators(1125899906842624, 0xaaaaaaaaaaaaa, 0x5555555555555),
+24: limitLocators(4503599627370496, 0x2aaaaaaaaaaaaa, 0x15555555555555),
+25: limitLocators(18014398509481984, 0xaaaaaaaaaaaaaa, 0x55555555555555),
+26: limitLocators(72057594037927936, 0x2aaaaaaaaaaaaaa, 0x155555555555555),
+27: limitLocators(288230376151711744, 0xaaaaaaaaaaaaaaa, 0x555555555555555),
+28: limitLocators(1152921504606846976, 0x2aaaaaaaaaaaaaaa, 0x1555555555555555), # 0x2aaaaaaaaaaaaaaa.bit_length() = 62
+29: limitLocators(4611686018427387904, 0xaaaaaaaaaaaaaaaa, 0x5555555555555555),
+30: limitLocators(18446744073709551616, 0x2aaaaaaaaaaaaaaaa, 0x15555555555555555),
+31: limitLocators(73786976294838206464, 0xaaaaaaaaaaaaaaaaa, 0x55555555555555555),
+32: limitLocators(295147905179352825856, 0x2aaaaaaaaaaaaaaaaa, 0x155555555555555555),
+33: limitLocators(1180591620717411303424, 0xaaaaaaaaaaaaaaaaaa, 0x555555555555555555),
+34: limitLocators(4722366482869645213696, 0x2aaaaaaaaaaaaaaaaaa, 0x1555555555555555555),
+35: limitLocators(18889465931478580854784, 0xaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555),
+36: limitLocators(75557863725914323419136, 0x2aaaaaaaaaaaaaaaaaaa, 0x15555555555555555555),
+37: limitLocators(302231454903657293676544, 0xaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555),
+38: limitLocators(1208925819614629174706176, 0x2aaaaaaaaaaaaaaaaaaaa, 0x155555555555555555555),
+39: limitLocators(4835703278458516698824704, 0xaaaaaaaaaaaaaaaaaaaaa, 0x555555555555555555555),
+40: limitLocators(19342813113834066795298816, 0x2aaaaaaaaaaaaaaaaaaaaa, 0x1555555555555555555555),
+41: limitLocators(77371252455336267181195264, 0xaaaaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555555),
+42: limitLocators(309485009821345068724781056, 0x2aaaaaaaaaaaaaaaaaaaaaa, 0x15555555555555555555555),
+43: limitLocators(1237940039285380274899124224, 0xaaaaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555555),
+44: limitLocators(4951760157141521099596496896, 0x2aaaaaaaaaaaaaaaaaaaaaaa, 0x155555555555555555555555),
+45: limitLocators(19807040628566084398385987584, 0xaaaaaaaaaaaaaaaaaaaaaaaa, 0x555555555555555555555555),
+46: limitLocators(79228162514264337593543950336, 0x2aaaaaaaaaaaaaaaaaaaaaaaa, 0x1555555555555555555555555),
+47: limitLocators(316912650057057350374175801344, 0xaaaaaaaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555555555),
+48: limitLocators(1267650600228229401496703205376, 0x2aaaaaaaaaaaaaaaaaaaaaaaaa, 0x15555555555555555555555555),
+49: limitLocators(5070602400912917605986812821504, 0xaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555555555),
+50: limitLocators(20282409603651670423947251286016, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaa, 0x155555555555555555555555555),
+51: limitLocators(81129638414606681695789005144064, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x555555555555555555555555555),
+52: limitLocators(324518553658426726783156020576256, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x1555555555555555555555555555),
+53: limitLocators(1298074214633706907132624082305024, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555555555555),
+54: limitLocators(5192296858534827628530496329220096, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x15555555555555555555555555555),
+55: limitLocators(20769187434139310514121985316880384, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555555555555),
+56: limitLocators(83076749736557242056487941267521536, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x155555555555555555555555555555),
+57: limitLocators(332306998946228968225951765070086144, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x555555555555555555555555555555),
+58: limitLocators(1329227995784915872903807060280344576, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x1555555555555555555555555555555),
+59: limitLocators(5316911983139663491615228241121378304, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x5555555555555555555555555555555),
+60: limitLocators(21267647932558653966460912964485513216, 0x2aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x15555555555555555555555555555555),
+61: limitLocators(85070591730234615865843651857942052864, 0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa, 0x55555555555555555555555555555555),
+}
+
+def makeCurveMaximum() -> None:
+	sys.stdout.write("curveMaximum: dict[int, limitLocators] = {\n")
+	for n in range(62):
+		curveLocationsMAXIMUM = 1 << (2 * n + 4)
+		bifurcationOddLocator = int('01' * ((curveLocationsMAXIMUM.bit_length() + 1) // 2), 2)
+		sys.stdout.write(f"{n}: limitLocators({curveLocationsMAXIMUM}, {hex(bifurcationOddLocator << 1)}, {hex(bifurcationOddLocator)}),\n")
+	sys.stdout.write("}\n")
+
+if __name__ == '__main__':
+	makeCurveMaximum()
+

mapFolding/_theSSOT.py

@@ -1,36 +1,31 @@
-"""
-Foundation layer for the map folding computational ecosystem.
-
-(AI generated docstring)
-
-This module establishes the fundamental configuration infrastructure that underpins
-all map folding operations. Map folding, as defined by Lunnon's 1971 algorithm,
-requires precise coordination of computational resources, type systems, and data
-flow management to solve the complex combinatorial problem of counting distinct
-folding patterns across multi-dimensional maps.
-
-The Single Source Of Truth (SSOT) principle governs this foundation, ensuring that
-package identity, filesystem locations, and concurrency configuration remain
-consistent across all computational phases. During packaging, static metadata is
-resolved from pyproject.toml. During installation, filesystem-dependent paths are
-dynamically discovered. During runtime, the `packageSettings` instance provides
-unified access to all configuration values, enabling the sophisticated computational
-framework that follows.
-
-This configuration foundation supports the type system definition, core utility
-functions, computational state management, result persistence, and ultimately the
-main computational interface that users interact with to solve map folding problems.
+"""Primary goal: access and configure package settings and metadata.
+
+Secondary goal: store hardcoded values until I implement a dynamic solution.
 """
 
+from collections.abc import Callable
 from hunterMakesPy import PackageSettings
+from pathlib import Path
+from typing import TypedDict
 import dataclasses
+import random
 
-packageNameHARDCODED = "mapFolding"
-"""Hardcoded package name used as fallback when dynamic resolution fails."""
-
+# TODO eliminate hardcoding
 concurrencyPackageHARDCODED = 'multiprocessing'
 """Default package identifier for concurrent execution operations."""
 
+class MetadataOEISidManuallySet(TypedDict):
+	"""Settings that are best selected by a human instead of algorithmically."""
+
+	getMapShape: Callable[[int], tuple[int, ...]]
+	"""Function to convert the OEIS sequence index, 'n', to its `mapShape` tuple."""
+	valuesBenchmark: list[int]
+	"""List of index values, 'n', to use when benchmarking the algorithm performance."""
+	valuesTestParallelization: list[int]
+	"""List of index values, 'n', to use when testing parallelization performance."""
+	valuesTestValidation: list[int]
+	"""List of index values, 'n', to use when testing validation performance."""
+
 @dataclasses.dataclass
 class mapFoldingPackageSettings(PackageSettings):
 	"""Centralized configuration container for all package-wide settings.
@@ -72,10 +67,57 @@ class mapFoldingPackageSettings(PackageSettings):
 	specialized numerical computations.
 	"""
 
+identifierPackageFALLBACK = "mapFolding"
+"""Hardcoded package name used as fallback when dynamic resolution fails."""
+
 concurrencyPackage = concurrencyPackageHARDCODED
 """Active concurrency package configuration for the current session."""
 
+# TODO I made a `TypedDict` before I knew how to make dataclasses and classes. Think about other data structures.
+settingsOEISManuallySelected: dict[str, MetadataOEISidManuallySet] = {
+	'A000136': {
+		'getMapShape': lambda n: tuple(sorted([1, n])),
+		'valuesBenchmark': [14],
+		'valuesTestParallelization': [*range(3, 7)],
+		'valuesTestValidation': [random.randint(2, 9)],  # noqa: S311
+	},
+	'A001415': {
+		'getMapShape': lambda n: tuple(sorted([2, n])),
+		'valuesBenchmark': [14],
+		'valuesTestParallelization': [*range(3, 7)],
+		'valuesTestValidation': [random.randint(2, 9)],  # noqa: S311
+	},
+	'A001416': {
+		'getMapShape': lambda n: tuple(sorted([3, n])),
+		'valuesBenchmark': [9],
+		'valuesTestParallelization': [*range(3, 5)],
+		'valuesTestValidation': [random.randint(2, 6)],  # noqa: S311
+	},
+	'A001417': {
+		'getMapShape': lambda n: tuple(2 for _dimension in range(n)),
+		'valuesBenchmark': [6],
+		'valuesTestParallelization': [*range(2, 4)],
+		'valuesTestValidation': [random.randint(2, 4)],  # noqa: S311
+	},
+	'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)],  # noqa: S311
+	},
+}
+
 packageSettings = mapFoldingPackageSettings(
-	identifierPackageFALLBACK=packageNameHARDCODED
+	identifierPackageFALLBACK=identifierPackageFALLBACK
 	, concurrencyPackage=concurrencyPackage)
 """Global package settings."""
+cacheDays = 30
+"""Number of days to retain cached OEIS data before refreshing from the online source."""
+pathCache: Path = packageSettings.pathPackage / ".cache"
+"""Local directory path for storing cached OEIS sequence data and metadata."""

mapFolding/basecamp.py

@@ -96,9 +96,9 @@ def countFolds(listDimensions: Sequence[int] | None = None  # noqa: C901, PLR091
 		pass
 	else:
 		if oeisID and oeis_n:
-			from mapFolding.oeis import settingsOEIS  # noqa: PLC0415
+			from mapFolding.oeis import dictionaryOEIS  # noqa: PLC0415
 			with contextlib.suppress(KeyError):
-				mapShape = settingsOEIS[oeisID]['getMapShape'](oeis_n)
+				mapShape = dictionaryOEIS[oeisID]['getMapShape'](oeis_n)
 		if not mapShape and listDimensions:
 			mapShape = validateListDimensions(listDimensions)
 

mapFolding/beDRY.py

@@ -319,7 +319,7 @@ def validateListDimensions(listDimensions: Sequence[int]) -> tuple[int, ...]:
 			message = f"I received `{dimension = }` in `{listDimensions = }`, but all dimensions must be a non-negative integer."
 			raise ValueError(message)
 		mapDimensions.append(dimension)
-	if len(mapDimensions) < 2:  # noqa: PLR2004
+	if len(mapDimensions) < 2:
 		message = f"This function requires `{listDimensions = }` to have at least two dimensions greater than 0. You may want to look at https://oeis.org/."
 		raise NotImplementedError(message)