mapFolding 0.9.2__py3-none-any.whl → 0.9.4__py3-none-any.whl

mapFolding/Z0Z_flowControl.py

@@ -0,0 +1,117 @@
+from collections.abc import Sequence
+from mapFolding import (
+	ComputationState,
+	getPathFilenameFoldsTotal,
+	outfitCountFolds,
+	saveFoldsTotal,
+	saveFoldsTotalFAILearly,
+	setProcessorLimit,
+	The,
+	validateListDimensions,
+)
+from os import PathLike
+from pathlib import PurePath
+
+def countFolds(listDimensions: Sequence[int] | None = None
+				, pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None
+				, computationDivisions: int | str | None = None
+				, CPUlimit: int | float | bool | None = None
+				# , * I need to improve `standardizedEqualToCallableReturn` so it will work with keyword arguments
+				, mapShape: tuple[int, ...] | None = None
+				, oeisID: str | None = None
+				, oeis_n: int | None = None
+				, flow: str | None = None
+				) -> int:
+
+	# mapShape =====================================================================
+
+	if mapShape:
+		pass
+	else:
+		if oeisID and oeis_n:
+			from mapFolding.oeis import settingsOEIS
+			try:
+				mapShape = settingsOEIS[oeisID]['getMapShape'](oeis_n)
+			except KeyError:
+				pass
+		if not mapShape and listDimensions:
+			mapShape = validateListDimensions(listDimensions)
+
+	if mapShape is None:
+		raise ValueError(f"""I received these values:
+	`{listDimensions = }`,
+	`{mapShape = }`,
+	`{oeisID = }` and `{oeis_n = }`,
+	but I was unable to select a map for which to count the folds.""")
+
+	# task division instructions ===============================================
+
+	if computationDivisions:
+		# NOTE `The.concurrencyPackage`
+		concurrencyLimit: int = setProcessorLimit(CPUlimit, The.concurrencyPackage)
+		from mapFolding.beDRY import getLeavesTotal, getTaskDivisions
+		leavesTotal: int = getLeavesTotal(mapShape)
+		taskDivisions = getTaskDivisions(computationDivisions, concurrencyLimit, leavesTotal)
+		del leavesTotal
+	else:
+		concurrencyLimit = 1
+		taskDivisions = 0
+
+	# memorialization instructions ===========================================
+
+	if pathLikeWriteFoldsTotal is not None:
+		pathFilenameFoldsTotal = getPathFilenameFoldsTotal(mapShape, pathLikeWriteFoldsTotal)
+		saveFoldsTotalFAILearly(pathFilenameFoldsTotal)
+	else:
+		pathFilenameFoldsTotal = None
+
+	# Flow control until I can figure out a good way ===============================
+
+	if flow == 'daoOfMapFolding':
+		from mapFolding.dataBaskets import MapFoldingState
+		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+		from mapFolding.daoOfMapFolding import doTheNeedful
+		mapFoldingState = doTheNeedful(mapFoldingState)
+		foldsTotal = mapFoldingState.foldsTotal
+
+	elif flow == 'theorem2' and any((dimension > 2 for dimension in mapShape)):
+		from mapFolding.dataBaskets import MapFoldingState
+		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+		from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
+		mapFoldingState = initializeGroupsOfFolds(mapFoldingState)
+
+		from mapFolding.syntheticModules.theorem2 import count
+		mapFoldingState = count(mapFoldingState)
+
+		foldsTotal = mapFoldingState.foldsTotal
+
+	elif (flow == 'theorem2Numba' or taskDivisions == 0) and any((dimension > 2 for dimension in mapShape)):
+		from mapFolding.dataBaskets import MapFoldingState
+		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+		from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
+		mapFoldingState = initializeGroupsOfFolds(mapFoldingState)
+
+		from mapFolding.syntheticModules.dataPacking import doTheNeedful
+		mapFoldingState = doTheNeedful(mapFoldingState)
+
+		foldsTotal = mapFoldingState.foldsTotal
+
+	# NOTE treat this as a default?
+	# flow based on `The` and `ComputationState` ====================================
+
+	else:
+		computationStateInitialized: ComputationState = outfitCountFolds(mapShape, computationDivisions, concurrencyLimit)
+		computationStateComplete: ComputationState = The.dispatcher(computationStateInitialized)
+
+		computationStateComplete.getFoldsTotal()
+		foldsTotal = computationStateComplete.foldsTotal
+
+	# Follow memorialization instructions ===========================================
+
+	if pathFilenameFoldsTotal is not None:
+		saveFoldsTotal(pathFilenameFoldsTotal, foldsTotal)
+
+	return foldsTotal

mapFolding/__init__.py

@@ -1,29 +1,27 @@
 """
 Map folding enumeration and counting algorithms with advanced optimization capabilities.
 
-This package implements algorithms to count and enumerate the distinct ways
-a rectangular map can be folded, based on the mathematical problem described
-in Lunnon's 1971 paper. It provides multiple layers of functionality, from
-high-level user interfaces to sophisticated algorithmic optimizations and code
-transformation tools.
+This package implements algorithms to count and enumerate the distinct ways a rectangular map can be folded, based on
+the mathematical problem described in Lunnon's 1971 paper. It provides multiple layers of functionality, from high-level
+user interfaces to sophisticated algorithmic optimizations and code transformation tools.
 
 Core modules:
 - basecamp: Public API with simplified interfaces for end users
 - theDao: Core computational algorithm using a functional state-transformation approach
-- beDRY: Core utility functions implementing consistent data handling, validation, and
-	resource management across the package's computational assembly-line
+- beDRY: Core utility functions implementing consistent data handling, validation, and resource management across the
+	package's computational assembly-line
 - theSSOT: Single Source of Truth for configuration, types, and state management
-- toolboxFilesystem: Cross-platform file management services for storing and retrieving
-	computation results with robust error handling and fallback mechanisms
+- toolboxFilesystem: Cross-platform file management services for storing and retrieving computation results with robust
+	error handling and fallback mechanisms
 - oeis: Interface to the Online Encyclopedia of Integer Sequences for known results
 
 Extended functionality:
-- someAssemblyRequired: Code transformation framework that optimizes the core algorithm
-	through AST manipulation, dataclass transformation, and compilation techniques
-	- The system converts readable code into high-performance implementations through
-	  a systematic analysis and transformation pipeline
-	- Provides tools to "shatter" complex dataclasses into primitive components,
-	  enabling compatibility with Numba and other optimization frameworks
+- someAssemblyRequired: Code transformation framework that optimizes the core algorithm through AST manipulation,
+	dataclass transformation, and compilation techniques
+	- The system converts readable code into high-performance implementations through a systematic analysis and
+		transformation assembly line
+	- Provides tools to "shatter" complex dataclasses into primitive components, enabling compatibility with Numba and
+		other optimization frameworks
 	- Creates specialized implementations tailored for specific input parameters
 
 Testing and extension:
@@ -35,24 +33,22 @@ Testing and extension:
 
 Special directories:
 - .cache/: Stores cached data from external sources like OEIS to improve performance
-- syntheticModules/: Contains dynamically generated, optimized implementations of the
-	core algorithm created by the code transformation framework
+- syntheticModules/: Contains dynamically generated, optimized implementations of the core algorithm created by the code
+transformation framework
 - reference/: Historical implementations and educational resources for algorithm exploration
-	- reference/jobsCompleted/: Contains successful computations for previously unknown values,
-		including first-ever calculations for 2x19 and 2x20 maps (OEIS A001415)
+	- reference/jobsCompleted/: Contains successful computations for previously unknown values, including first-ever
+		calculations for 2x19 and 2x20 maps (OEIS A001415)
 
-This package balances algorithm readability and understandability with
-high-performance computation capabilities, allowing users to compute map folding
-totals for larger dimensions than previously feasible while also providing
-a foundation for exploring advanced code transformation techniques.
+This package balances algorithm readability and understandability with high-performance computation capabilities,
+allowing users to compute map folding totals for larger dimensions than previously feasible while also providing a
+foundation for exploring advanced code transformation techniques.
 """
 
-from mapFolding.theSSOT import (
+from mapFolding.datatypes import (
 	Array1DElephino as Array1DElephino,
 	Array1DFoldsTotal as Array1DFoldsTotal,
 	Array1DLeavesTotal as Array1DLeavesTotal,
 	Array3D as Array3D,
-	ComputationState as ComputationState,
 	DatatypeElephino as DatatypeElephino,
 	DatatypeFoldsTotal as DatatypeFoldsTotal,
 	DatatypeLeavesTotal as DatatypeLeavesTotal,
@@ -60,6 +56,10 @@ from mapFolding.theSSOT import (
 	NumPyFoldsTotal as NumPyFoldsTotal,
 	NumPyIntegerType as NumPyIntegerType,
 	NumPyLeavesTotal as NumPyLeavesTotal,
+)
+
+from mapFolding.theSSOT import (
+	ComputationState as ComputationState,
 	raiseIfNoneGitHubIssueNumber3 as raiseIfNoneGitHubIssueNumber3,
 	The as The,
 )
@@ -70,6 +70,8 @@ from mapFolding.theDao import (
 )
 
 from mapFolding.beDRY import (
+	getLeavesTotal as getLeavesTotal,
+	getTaskDivisions as getTaskDivisions,
 	outfitCountFolds as outfitCountFolds,
 	setProcessorLimit as setProcessorLimit,
 	validateListDimensions as validateListDimensions,
@@ -83,7 +85,7 @@ from mapFolding.toolboxFilesystem import (
 	writeStringToHere as writeStringToHere,
 )
 
-from mapFolding.basecamp import countFolds as countFolds
+from mapFolding.Z0Z_flowControl import countFolds
 
 from mapFolding.oeis import (
 	clearOEIScache as clearOEIScache,

mapFolding/basecamp.py

@@ -63,7 +63,7 @@ def countFolds(listDimensions: Sequence[int]
 
 	Note well
 	---------
-	You probably don't want to divide the computation into tasks.
+	You probably do not want to divide your 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

mapFolding/beDRY.py

@@ -29,8 +29,7 @@ def getLeavesTotal(mapShape: tuple[int, ...]) -> int:
 	"""
 	Calculate the total number of leaves in a map with the given dimensions.
 
-	The total number of leaves is the product of all dimensions in the map shape. This value is foundational for
-	initializing the computation state and determining task divisions.
+	The total number of leaves is the product of all dimensions in the map shape.
 
 	Parameters
 	----------

mapFolding/daoOfMapFolding.py

@@ -0,0 +1,142 @@
+from mapFolding.dataBaskets import MapFoldingState
+
+def activeLeafGreaterThan0(state: MapFoldingState) -> bool:
+	return state.leaf1ndex > 0
+
+def activeLeafGreaterThanLeavesTotal(state: MapFoldingState) -> bool:
+	return state.leaf1ndex > state.leavesTotal
+
+def activeLeafIsTheFirstLeaf(state: MapFoldingState) -> bool:
+	return state.leaf1ndex <= 1
+
+def activeLeafIsUnconstrainedInAllDimensions(state: MapFoldingState) -> bool:
+	return not state.dimensionsUnconstrained
+
+def activeLeafUnconstrainedInThisDimension(state: MapFoldingState) -> MapFoldingState:
+	state.dimensionsUnconstrained -= 1
+	return state
+
+def filterCommonGaps(state: MapFoldingState) -> MapFoldingState:
+	state.gapsWhere[state.gap1ndex] = state.gapsWhere[state.indexMiniGap]
+	if state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] == state.dimensionsUnconstrained:
+		state = incrementActiveGap(state)
+	state.countDimensionsGapped[state.gapsWhere[state.indexMiniGap]] = 0
+	return state
+
+def gapAvailable(state: MapFoldingState) -> bool:
+	return state.leaf1ndex > 0
+
+def incrementActiveGap(state: MapFoldingState) -> MapFoldingState:
+	state.gap1ndex += 1
+	return state
+
+def incrementGap1ndexCeiling(state: MapFoldingState) -> MapFoldingState:
+	state.gap1ndexCeiling += 1
+	return state
+
+def incrementIndexMiniGap(state: MapFoldingState) -> MapFoldingState:
+	state.indexMiniGap += 1
+	return state
+
+def initializeIndexMiniGap(state: MapFoldingState) -> MapFoldingState:
+	state.indexMiniGap = state.gap1ndex
+	return state
+
+def initializeVariablesToFindGaps(state: MapFoldingState) -> MapFoldingState:
+	state.dimensionsUnconstrained = state.dimensionsTotal
+	state.gap1ndexCeiling = state.gapRangeStart[state.leaf1ndex - 1]
+	state.indexDimension = 0
+	return state
+
+def insertActiveLeaf(state: MapFoldingState) -> MapFoldingState:
+	state.indexLeaf = 0
+	while state.indexLeaf < state.leaf1ndex:
+		state.gapsWhere[state.gap1ndexCeiling] = state.indexLeaf
+		state.gap1ndexCeiling += 1
+		state.indexLeaf += 1
+	return state
+
+def insertActiveLeafAtGap(state: MapFoldingState) -> MapFoldingState:
+	state.gap1ndex -= 1
+	state.leafAbove[state.leaf1ndex] = state.gapsWhere[state.gap1ndex]
+	state.leafBelow[state.leaf1ndex] = state.leafBelow[state.leafAbove[state.leaf1ndex]]
+	state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leaf1ndex
+	state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leaf1ndex
+	state.gapRangeStart[state.leaf1ndex] = state.gap1ndex
+	state.leaf1ndex += 1
+	return state
+
+def leafBelowSentinelIs1(state: MapFoldingState) -> bool:
+	return state.leafBelow[0] == 1
+
+def leafConnecteeIsActiveLeaf(state: MapFoldingState) -> bool:
+	return state.leafConnectee == state.leaf1ndex
+
+def lookForGaps(state: MapFoldingState) -> MapFoldingState:
+	state.gapsWhere[state.gap1ndexCeiling] = state.leafConnectee
+	if state.countDimensionsGapped[state.leafConnectee] == 0:
+		state = incrementGap1ndexCeiling(state)
+	state.countDimensionsGapped[state.leafConnectee] += 1
+	return state
+
+def lookupLeafConnecteeInConnectionGraph(state: MapFoldingState) -> MapFoldingState:
+	state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leaf1ndex]
+	return state
+
+def loopingLeavesConnectedToActiveLeaf(state: MapFoldingState) -> bool:
+	return state.leafConnectee != state.leaf1ndex
+
+def loopingThroughTheDimensions(state: MapFoldingState) -> bool:
+	return state.indexDimension < state.dimensionsTotal
+
+def loopingToActiveGapCeiling(state: MapFoldingState) -> bool:
+	return state.indexMiniGap < state.gap1ndexCeiling
+
+def noGapsHere(state: MapFoldingState) -> bool:
+	return (state.leaf1ndex > 0) and (state.gap1ndex == state.gapRangeStart[state.leaf1ndex - 1])
+
+def tryAnotherLeafConnectee(state: MapFoldingState) -> MapFoldingState:
+	state.leafConnectee = state.connectionGraph[state.indexDimension, state.leaf1ndex, state.leafBelow[state.leafConnectee]]
+	return state
+
+def tryNextDimension(state: MapFoldingState) -> MapFoldingState:
+	state.indexDimension += 1
+	return state
+
+def undoLastLeafPlacement(state: MapFoldingState) -> MapFoldingState:
+	state.leaf1ndex -= 1
+	state.leafBelow[state.leafAbove[state.leaf1ndex]] = state.leafBelow[state.leaf1ndex]
+	state.leafAbove[state.leafBelow[state.leaf1ndex]] = state.leafAbove[state.leaf1ndex]
+	return state
+
+def count(state: MapFoldingState) -> MapFoldingState:
+	while activeLeafGreaterThan0(state):
+		if activeLeafIsTheFirstLeaf(state) or leafBelowSentinelIs1(state):
+			if activeLeafGreaterThanLeavesTotal(state):
+				state.groupsOfFolds += 1
+			else:
+				state = initializeVariablesToFindGaps(state)
+				while loopingThroughTheDimensions(state):
+					state = lookupLeafConnecteeInConnectionGraph(state)
+					if leafConnecteeIsActiveLeaf(state):
+						state = activeLeafUnconstrainedInThisDimension(state)
+					else:
+						while loopingLeavesConnectedToActiveLeaf(state):
+							state = lookForGaps(state)
+							state = tryAnotherLeafConnectee(state)
+					state = tryNextDimension(state)
+				if activeLeafIsUnconstrainedInAllDimensions(state):
+					state = insertActiveLeaf(state)
+				state = initializeIndexMiniGap(state)
+				while loopingToActiveGapCeiling(state):
+					state = filterCommonGaps(state)
+					state = incrementIndexMiniGap(state)
+		while noGapsHere(state):
+			state = undoLastLeafPlacement(state)
+		if gapAvailable(state):
+			state = insertActiveLeafAtGap(state)
+	return state
+
+def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
+	state = count(state)
+	return state

mapFolding/dataBaskets.py

@@ -0,0 +1,49 @@
+from mapFolding.beDRY import getConnectionGraph, getLeavesTotal, makeDataContainer
+from mapFolding.datatypes import Array3D, Array1DElephino, Array1DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
+import dataclasses
+
+@dataclasses.dataclass
+class MapFoldingState:
+	mapShape: tuple[DatatypeLeavesTotal, ...] = dataclasses.field(init=True, metadata={'elementConstructor': 'DatatypeLeavesTotal'})
+
+	groupsOfFolds: DatatypeFoldsTotal = dataclasses.field(default=DatatypeFoldsTotal(0), metadata={'theCountingIdentifier': True})
+
+	gap1ndex: DatatypeElephino = DatatypeElephino(0)
+	gap1ndexCeiling: DatatypeElephino = DatatypeElephino(0)
+	indexDimension: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+	indexLeaf: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+	indexMiniGap: DatatypeElephino = DatatypeElephino(0)
+	leaf1ndex: DatatypeLeavesTotal = DatatypeLeavesTotal(1)
+	leafConnectee: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+
+	dimensionsUnconstrained: DatatypeLeavesTotal = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+
+	countDimensionsGapped: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	gapRangeStart: Array1DElephino = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DElephino.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	gapsWhere: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	leafAbove: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	leafBelow: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+
+	connectionGraph: Array3D = dataclasses.field(init=False, metadata={'dtype': Array3D.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
+	dimensionsTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
+	leavesTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
+
+	@property
+	def foldsTotal(self) -> DatatypeFoldsTotal:
+		_foldsTotal = DatatypeFoldsTotal(self.leavesTotal) * self.groupsOfFolds
+		return _foldsTotal
+
+	def __post_init__(self) -> None:
+		self.dimensionsTotal = DatatypeLeavesTotal(len(self.mapShape))
+		self.leavesTotal = DatatypeLeavesTotal(getLeavesTotal(self.mapShape))
+
+		leavesTotalAsInt = int(self.leavesTotal)
+
+		self.connectionGraph = getConnectionGraph(self.mapShape, leavesTotalAsInt, self.__dataclass_fields__['connectionGraph'].metadata['dtype'])
+
+		if self.dimensionsUnconstrained is None: self.dimensionsUnconstrained = DatatypeLeavesTotal(int(self.dimensionsTotal)) # pyright: ignore[reportUnnecessaryComparison]
+		if self.gapsWhere is None: self.gapsWhere = makeDataContainer(leavesTotalAsInt * leavesTotalAsInt + 1, self.__dataclass_fields__['gapsWhere'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
+		if self.countDimensionsGapped is None: self.countDimensionsGapped = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['countDimensionsGapped'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
+		if self.gapRangeStart is None: self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['gapRangeStart'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
+		if self.leafAbove is None: self.leafAbove = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafAbove'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
+		if self.leafBelow is None: self.leafBelow = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafBelow'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]

mapFolding/datatypes.py

@@ -0,0 +1,21 @@
+from numpy import dtype, int64 as numpy_int64, integer, ndarray
+from typing import Any, TypeAlias, TypeVar
+
+# =============================================================================
+# Flexible Data Structure System Needs Enhanced Paradigm https://github.com/hunterhogan/mapFolding/issues/9
+
+NumPyIntegerType = TypeVar('NumPyIntegerType', bound=integer[Any], covariant=True)
+
+DatatypeLeavesTotal: TypeAlias = int
+NumPyLeavesTotal: TypeAlias = numpy_int64
+
+DatatypeElephino: TypeAlias = int
+NumPyElephino: TypeAlias = numpy_int64
+
+DatatypeFoldsTotal: TypeAlias = int
+NumPyFoldsTotal: TypeAlias = numpy_int64
+
+Array3D: TypeAlias = ndarray[tuple[int, int, int], dtype[NumPyLeavesTotal]]
+Array1DLeavesTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyLeavesTotal]]
+Array1DElephino: TypeAlias = ndarray[tuple[int], dtype[NumPyElephino]]
+Array1DFoldsTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyFoldsTotal]]

mapFolding/oeis.py

@@ -20,7 +20,7 @@ mathematical definition in OEIS and the computational implementation in the pack
 from collections.abc import Callable
 from datetime import datetime, timedelta
 from functools import cache
-from mapFolding import writeStringToHere, The
+from mapFolding import countFolds, The, writeStringToHere
 from pathlib import Path
 from typing import Any, Final, TYPE_CHECKING
 import argparse
@@ -401,7 +401,6 @@ def oeisIDfor_n(oeisID: str, n: int | Any) -> int:
 			raise ArithmeticError(f"OEIS sequence {oeisID} is not defined at {n = }.")
 		foldsTotal: int = settingsOEIS[oeisID]['valuesKnown'][n]
 		return foldsTotal
-	from mapFolding.basecamp import countFolds
 	return countFolds(mapShape)
 
 def OEIS_for_n() -> None: