mapFolding 0.16.0__py3-none-any.whl → 0.16.2__py3-none-any.whl

easyRun/A000682.py

@@ -0,0 +1,25 @@
+# ruff: noqa
+# pyright: basic
+from mapFolding.basecamp import NOTcountingFolds
+import sys
+import warnings
+
+if sys.version_info >= (3, 14):
+	warnings.filterwarnings("ignore", category=FutureWarning)
+
+def main():
+	oeisID = 'A000682'
+	n=45
+	print(NOTcountingFolds(oeisID, n, 'matrixNumPy'))
+
+	from mapFolding import dictionaryOEIS
+	if n < dictionaryOEIS[oeisID]['valueUnknown']:
+		print(dictionaryOEIS[oeisID]['valuesKnown'][n])
+
+if __name__ == "__main__":
+	main()
+
+r"""
+deactivate && C:\apps\mapFolding\.vtail\Scripts\activate.bat && title good && cls
+title running && start "running" /B /HIGH /wait py -X faulthandler=0 -X tracemalloc=0 -X frozen_modules=on easyRun\A000682.py && title I'm done || title Error
+"""

easyRun/A005316.py

@@ -0,0 +1,20 @@
+# ruff: noqa
+# pyright: basic
+from mapFolding.basecamp import NOTcountingFolds
+import warnings
+
+warnings.filterwarnings("ignore", category=FutureWarning)
+
+n=25
+print(NOTcountingFolds('A005316', n))
+
+from mapFolding import dictionaryOEIS
+
+if n < dictionaryOEIS['A005316']['valueUnknown']:
+	print(dictionaryOEIS['A005316']['valuesKnown'][n])
+
+
+r"""
+deactivate && C:\apps\mapFolding\.vtail\Scripts\activate.bat && title good && cls
+
+"""

easyRun/NOTcountingFolds.py

@@ -0,0 +1,36 @@
+# ruff: noqa
+from mapFolding import dictionaryOEIS
+from mapFolding.basecamp import NOTcountingFolds
+import sys
+import time
+
+if __name__ == '__main__':
+	def _write() -> None:
+		sys.stdout.write(
+			f"{(match:=countTotal == dictionaryOEIS[oeisID]['valuesKnown'][n])}\t"
+			f"\033[{(not match)*91}m"
+			f"{n}\t"
+			f"{countTotal}\t"
+			f"{time.perf_counter() - timeStart:.2f}\t"
+			"\033[0m\n"
+		)
+
+	CPUlimit: bool | float | int | None = -2
+	# oeisID: str | None = None
+	oeis_n: int | None = None
+	flow: str | None = None
+
+	oeisID = 'A007822'
+
+	flow = 'asynchronous'
+	flow = 'algorithm'
+	flow = 'asynchronousNumba'
+	flow = 'theorem2Numba'
+	flow = 'asynchronousTrimmed'
+
+	for n in range(3,9):
+
+		timeStart = time.perf_counter()
+		countTotal = NOTcountingFolds(oeisID, n, flow, CPUlimit)
+
+		_write()

easyRun/countFolds.py

@@ -0,0 +1,41 @@
+# ruff: noqa
+# pyright: basic
+from collections.abc import Sequence
+from mapFolding import countFolds, dictionaryOEISMapFolding
+from os import PathLike
+from pathlib import PurePath
+import sys
+import time
+
+if __name__ == '__main__':
+	def _write() -> None:
+		sys.stdout.write(
+			f"{(match:=foldsTotal == dictionaryOEISMapFolding[oeisID]['valuesKnown'][n])}\t"
+			f"\033[{(not match)*91}m"
+			f"{n}\t"
+			f"{foldsTotal}\t"
+			f"{time.perf_counter() - timeStart:.2f}\t"
+			"\033[0m\n"
+		)
+
+	listDimensions: Sequence[int] | None = None
+	pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None
+	computationDivisions: int | str | None = None
+	CPUlimit: bool | float | int | None = None
+	# mapShape: tuple[int, ...] | None = None
+	flow: str | None = 'theorem2Numba'
+
+	oeisID: str = 'A001415'
+	for n in range(3,8):
+
+		mapShape: tuple[int, ...] = dictionaryOEISMapFolding[oeisID]['getMapShape'](n)
+
+		timeStart = time.perf_counter()
+		foldsTotal: int = countFolds(listDimensions=listDimensions
+						, pathLikeWriteFoldsTotal=pathLikeWriteFoldsTotal
+						, computationDivisions=computationDivisions
+						, CPUlimit=CPUlimit
+						, mapShape=mapShape
+						, flow=flow)
+
+		_write()

easyRun/meanders.py

@@ -0,0 +1,69 @@
+# ruff: noqa
+# pyright: basic
+from mapFolding import dictionaryOEIS
+from mapFolding.basecamp import NOTcountingFolds
+import gc
+import multiprocessing
+import sys
+import time
+import warnings
+
+def write() -> None:
+	sys.stdout.write(
+		f"{(booleanColor:=(countTotal == dictionaryOEIS[oeisID]['valuesKnown'][n]))}\t"
+		f"\033[{(not booleanColor)*91}m"
+		f"{n}\t"
+		# f"{countTotal}\t"
+		# f"{dictionaryOEISMeanders[oeisID]['valuesKnown'][n]}\t"
+		f"{time.perf_counter() - timeStart:.2f}\t"
+		"\033[0m\n"
+	)
+
+if __name__ == '__main__':
+	multiprocessing.set_start_method('spawn')
+	if sys.version_info >= (3, 14):
+		warnings.filterwarnings("ignore", category=FutureWarning)
+
+	flow = 'matrixMeanders'
+	flow = 'matrixPandas'
+	flow = 'matrixNumPy'
+
+	for oeisID in [
+			# 'A005316',
+			'A000682',
+				]:
+		sys.stdout.write(f"\n{oeisID}\n")
+
+		"""TODO Identifiers. improve
+		"generate up to four targets."
+		1. Adding a new loop.
+		2. Dragging up a loop end.
+		3. Dragging down a loop end.
+		4. Connect ends across the line.
+
+		flipTheExtra_0b1AsUfunc: what is extra?
+		"""
+
+		nList: list[int] = []
+		nList.extend(range(2, 10))
+		# nList.extend(range(2, 28))
+		nList.extend(range(28,33))
+		# nList.extend(range(33,38))
+		# nList.extend(range(38,43))
+		# nList.extend(range(43,45))
+		# nList.extend(range(47,57))
+
+		for n in nList:
+			gc.collect()
+			timeStart = time.perf_counter()
+			countTotal = NOTcountingFolds(oeisID, n, flow)
+			if n < dictionaryOEIS[oeisID]['valueUnknown']:
+				write()
+			else:
+				sys.stdout.write(f"{n} {countTotal} {time.perf_counter() - timeStart:.2f}\n")
+
+r"""
+deactivate && C:\apps\mapFolding\.vtail\Scripts\activate.bat && title good && cls
+title running && start "meanders" /B /HIGH /wait py -X faulthandler=0 -X tracemalloc=0 -X frozen_modules=on easyRun\meanders.py && title I'm done || title Error
+
+"""

mapFolding/__init__.py

@@ -1,63 +1,24 @@
-"""Computational toolkit for analyzing multi-dimensional map folding patterns.
-
-(AI generated docstring)
-
-The mapFolding package provides a complete implementation of Lunnon's 1971 algorithm
-for counting distinct folding patterns in multi-dimensional maps. This toolkit
-transforms the complex combinatorial mathematics of map folding into accessible
-computational tools, enabling researchers and practitioners to analyze folding
-patterns across dimensions from simple 2D strips to complex multi-dimensional
-hypercubes.
-
-The package architecture follows Domain-Driven Design principles, organizing
-functionality around mathematical concepts rather than implementation details.
-The computational framework integrates type safety, persistent result storage,
-and mathematical validation through OEIS sequence integration.
-
-Core Transformation Tools:
-	countFolds: Primary interface for computing folding pattern counts
-	MapFoldingState: Computational state management for recursive analysis
-	Connection graph generation: Mathematical foundation for folding relationships
-	Task division utilities: Experimental parallel computation options
-	OEIS integration: Mathematical validation and sequence discovery
-
-Primary Use Cases:
-	Mathematical research into folding pattern properties and relationships
-	Educational exploration of combinatorial mathematics concepts
-	Computational validation of theoretical results
-	Extension of known mathematical sequences through new discoveries
-
-The package handles the full spectrum of map folding analysis, from simple
-educational examples to research-grade computations requiring multi-day processing
-time. Results integrate seamlessly with the mathematical community through
-comprehensive OEIS connectivity and standardized result persistence.
-
-For researchers: The computational foundation supports both replication of
-established results and discovery of new mathematical relationships.
-
-For educators: The clear interfaces and type safety enable confident exploration
-of combinatorial concepts without computational complexity barriers.
-
-For practitioners: The robust result persistence and type safety ensure
-reliable completion of complex analytical tasks.
-"""
+"""Map folding, meanders, stamp folding, semi-meanders. Experiment with algorithm transformations, and analyze computational states."""
 
 from mapFolding._theTypes import (
 	Array1DElephino as Array1DElephino,
 	Array1DFoldsTotal as Array1DFoldsTotal,
 	Array1DLeavesTotal as Array1DLeavesTotal,
 	Array3DLeavesTotal as Array3DLeavesTotal,
+    axisOfLength as axisOfLength,
 	DatatypeElephino as DatatypeElephino,
 	DatatypeFoldsTotal as DatatypeFoldsTotal,
 	DatatypeLeavesTotal as DatatypeLeavesTotal,
+	MetadataOEISid as MetadataOEISid,
+	MetadataOEISidManuallySet as MetadataOEISidManuallySet,
 	MetadataOEISidMapFolding as MetadataOEISidMapFolding,
 	MetadataOEISidMapFoldingManuallySet as MetadataOEISidMapFoldingManuallySet,
-	MetadataOEISidMeanders as MetadataOEISidMeanders,
-	MetadataOEISidMeandersManuallySet as MetadataOEISidMeandersManuallySet,
 	NumPyElephino as NumPyElephino,
 	NumPyFoldsTotal as NumPyFoldsTotal,
 	NumPyIntegerType as NumPyIntegerType,
-	NumPyLeavesTotal as NumPyLeavesTotal)
+	NumPyLeavesTotal as NumPyLeavesTotal,
+	ShapeArray as ShapeArray,
+	ShapeSlicer as ShapeSlicer)
 
 from mapFolding._theSSOT import packageSettings as packageSettings
 
@@ -69,10 +30,6 @@ from mapFolding.beDRY import (
 	setProcessorLimit as setProcessorLimit,
 	validateListDimensions as validateListDimensions)
 
-from mapFolding.dataBaskets import (
-    MapFoldingState as MapFoldingState,
-    MatrixMeandersState as MatrixMeandersState)
-
 from mapFolding.filesystemToolkit import (
 	getFilenameFoldsTotal as getFilenameFoldsTotal,
 	getPathFilenameFoldsTotal as getPathFilenameFoldsTotal,
@@ -83,8 +40,8 @@ from mapFolding.filesystemToolkit import (
 from mapFolding.basecamp import countFolds as countFolds
 
 from mapFolding.oeis import (
+	dictionaryOEIS as dictionaryOEIS,
 	dictionaryOEISMapFolding as dictionaryOEISMapFolding,
-	dictionaryOEISMeanders as dictionaryOEISMeanders,
 	getFoldsTotalKnown as getFoldsTotalKnown,
 	getOEISids as getOEISids,
 	OEIS_for_n as OEIS_for_n,

mapFolding/_dataPacking.py

@@ -0,0 +1,68 @@
+from collections.abc import Callable
+from mapFolding.dataBaskets import MapFoldingState
+from typing import Any
+import astToolkit
+import dataclasses
+import functools
+import inspect
+
+r"""Notes
+Goal: create a decorator, `unRePackMapFoldingState`, that will unpack `MapFoldingState`, pass only the parameters in the decorated function, receive the
+values returned by the function, and repack `MapFoldingState`.
+
+You must use dynamic programming. If the datatype or the field name changes, for example, that should not affect the decorator.
+
+To use in, for example, C:\apps\mapFolding\mapFolding\syntheticModules\A007822\theorem2Numba.py. Analogous to
+`Z0Z_tools.waveformSpectrogramWaveform`, see
+https://github.com/hunterhogan/Z0Z_tools/blob/2c393c2831382dfe6f3e742cf56db39e71126cbc/Z0Z_tools/ioAudio.py
+
+For examples of manipulating `dataclasses`, see also:
+C:\apps\mapFolding\mapFolding\someAssemblyRequired\_toolkitContainers.py and
+C:\apps\mapFolding\mapFolding\someAssemblyRequired\transformationTools.py
+
+- `TypeVar` may be useful.
+
+- `dataclasses` has inspection tools.
+
+- `return MapFoldingState(...` Check if the field is init=True
+
+Prototype. Eventual home will probably be "beDry.py".
+"""
+
+def unRePackMapFoldingState[CallableTargetType: Callable[..., Any]](callableTarget: CallableTargetType) -> Callable[[MapFoldingState], MapFoldingState]:
+	signatureTargetFunction: inspect.Signature = inspect.signature(callableTarget)
+	parametersTargetFunction: list[str] = list(signatureTargetFunction.parameters.keys())
+
+	fieldsMapFoldingState: tuple[dataclasses.Field[Any], ...] = dataclasses.fields(MapFoldingState)
+
+	fieldsInitializable: dict[str, dataclasses.Field[Any]] = {field.name: field for field in fieldsMapFoldingState if field.init}
+
+	@functools.wraps(callableTarget)
+	def decoratedFunction(mapFoldingStateInstance: MapFoldingState, **additionalKeywordArguments: Any) -> MapFoldingState:
+		dataclassAsDict: dict[str, Any] = dataclasses.asdict(mapFoldingStateInstance)
+
+		argumentsForTargetFunction: list[Any] = []
+		for parameterName in parametersTargetFunction:
+			if parameterName in dataclassAsDict:
+				argumentsForTargetFunction.append(dataclassAsDict[parameterName])
+			elif parameterName in additionalKeywordArguments:
+				argumentsForTargetFunction.append(additionalKeywordArguments[parameterName])
+			else:
+				errorMessage = f"Parameter '{parameterName}' not found in MapFoldingState or additional arguments"
+				raise ValueError(errorMessage)
+
+		returnedFromTargetFunction: Any = callableTarget(*argumentsForTargetFunction)
+
+		argumentsForMapFoldingStateConstructor: dict[str, Any] = {fieldName: dataclassAsDict[fieldName] for fieldName in fieldsInitializable}
+
+		if len(parametersTargetFunction) == 1:
+			singleParameterName: str = parametersTargetFunction[0]
+			if singleParameterName in fieldsInitializable:
+				argumentsForMapFoldingStateConstructor[singleParameterName] = returnedFromTargetFunction
+		elif isinstance(returnedFromTargetFunction, tuple) and len(returnedFromTargetFunction) == len(parametersTargetFunction):
+			updatedFieldsFromReturn: dict[str, Any] = {parameterName: returnedValue for parameterName, returnedValue in zip(parametersTargetFunction, returnedFromTargetFunction, strict=True) if parameterName in fieldsInitializable}
+			argumentsForMapFoldingStateConstructor.update(updatedFieldsFromReturn)
+
+		return MapFoldingState(**argumentsForMapFoldingStateConstructor)
+
+	return decoratedFunction

mapFolding/_theSSOT.py

@@ -1,7 +1,7 @@
 """Access and configure package settings and metadata."""
 
 from hunterMakesPy import PackageSettings
-from mapFolding._theTypes import MetadataOEISidMapFoldingManuallySet, MetadataOEISidMeandersManuallySet
+from mapFolding._theTypes import MetadataOEISidManuallySet, MetadataOEISidMapFoldingManuallySet
 from pathlib import Path
 import dataclasses
 import random
@@ -27,14 +27,14 @@ class mapFoldingPackageSettings(PackageSettings):
 		Package identifier for concurrent execution operations.
 	OEISidMapFoldingManuallySet : dict[str, MetadataOEISidMapFoldingManuallySet]
 		Settings that are best selected by a human instead of algorithmically.
-	OEISidMeandersManuallySet : dict[str, MetadataOEISidMeandersManuallySet]
+	OEISidManuallySet : dict[str, MetadataOEISidMeandersManuallySet]
 		Settings that are best selected by a human instead of algorithmically for meander sequences.
 	"""
 
 	OEISidMapFoldingManuallySet: dict[str, MetadataOEISidMapFoldingManuallySet] = dataclasses.field(default_factory=dict[str, MetadataOEISidMapFoldingManuallySet])
 	"""Settings that are best selected by a human instead of algorithmically."""
 
-	OEISidMeandersManuallySet: dict[str, MetadataOEISidMeandersManuallySet] = dataclasses.field(default_factory=dict[str, MetadataOEISidMeandersManuallySet])
+	OEISidManuallySet: dict[str, MetadataOEISidManuallySet] = dataclasses.field(default_factory=dict[str, MetadataOEISidManuallySet])
 	"""Settings that are best selected by a human instead of algorithmically for meander sequences."""
 
 	cacheDays: int = 30
@@ -42,50 +42,44 @@ class mapFoldingPackageSettings(PackageSettings):
 
 	concurrencyPackage: str = 'multiprocessing'
 	"""Package identifier for concurrent execution operations."""
-
+# ruff: noqa: S311
 # TODO I made a `TypedDict` before I knew how to make dataclasses and classes. Think about other data structures.
 OEISidMapFoldingManuallySet: dict[str, MetadataOEISidMapFoldingManuallySet] = {
 	'A000136': {
 		'getMapShape': lambda n: (1, n),
 		'valuesBenchmark': [14],
-		'valuesTestParallelization': [*range(3, 7)],
-		'valuesTestValidation': [random.randint(2, 9)],  # noqa: S311
+		'valuesTestParallelization': [random.randint(3, 7)],
+		'valuesTestValidation': [random.randint(2, 9)],
 	},
 	'A001415': {
 		'getMapShape': lambda n: (2, n),
 		'valuesBenchmark': [14],
-		'valuesTestParallelization': [*range(3, 7)],
-		'valuesTestValidation': [random.randint(2, 9)],  # noqa: S311
+		'valuesTestParallelization': [random.randint(3, 7)],
+		'valuesTestValidation': [random.randint(2, 9)],
 	},
 	'A001416': {
 		'getMapShape': lambda n: (3, n),
 		'valuesBenchmark': [9],
-		'valuesTestParallelization': [*range(3, 5)],
-		'valuesTestValidation': [random.randint(2, 6)],  # noqa: S311
+		'valuesTestParallelization': [random.randint(3, 5)],
+		'valuesTestValidation': [random.randint(2, 6)],
 	},
 	'A001417': {
 		'getMapShape': lambda n: tuple(2 for _dimension in range(n)),
 		'valuesBenchmark': [6],
-		'valuesTestParallelization': [*range(2, 4)],
-		'valuesTestValidation': [random.randint(2, 4)],  # noqa: S311
+		'valuesTestParallelization': [random.randint(2, 4)],
+		'valuesTestValidation': [random.randint(2, 4)],
 	},
 	'A195646': {
 		'getMapShape': lambda n: tuple(3 for _dimension in range(n)),
 		'valuesBenchmark': [3],
-		'valuesTestParallelization': [*range(2, 3)],
+		'valuesTestParallelization': [2],
 		'valuesTestValidation': [2],
 	},
 	'A001418': {
 		'getMapShape': lambda n: (n, n),
 		'valuesBenchmark': [5],
 		'valuesTestParallelization': [*range(2, 4)],
-		'valuesTestValidation': [random.randint(2, 4)],  # noqa: S311
-	},
-	'A007822': {
-		'getMapShape': lambda n: (1, 2 * n),
-		'valuesBenchmark': [7],
-		'valuesTestParallelization': [*range(2, 4)],
-		'valuesTestValidation': [random.randint(2, 8)],  # noqa: S311
+		'valuesTestValidation': [random.randint(2, 4)],
 	},
 }
 
@@ -95,29 +89,31 @@ identifierPackageFALLBACK = "mapFolding"
 packageSettings = mapFoldingPackageSettings(identifierPackageFALLBACK=identifierPackageFALLBACK, OEISidMapFoldingManuallySet=OEISidMapFoldingManuallySet)
 """Global package settings."""
 
-# TODO integrate into packageSettings
-pathCache: Path = packageSettings.pathPackage / ".cache"
 """Local directory path for storing cached OEIS sequence data and metadata."""
-OEISidMeandersManuallySet: dict[str, MetadataOEISidMeandersManuallySet] = {
-	'A000560': {'valuesTestValidation': [*range(3, 12)]},
-	'A000682': {'valuesTestValidation': [*range(3, 12)]},
-	'A001010': {'valuesTestValidation': [*range(3, 11)]},
-	'A001011': {'valuesTestValidation': [*range(3, 7)]},
-	'A005315': {'valuesTestValidation': [*range(3, 9)]},
-	'A005316': {'valuesTestValidation': [*range(3, 13)]},
-	'A060206': {'valuesTestValidation': [*range(3, 9)]},
-	'A077460': {'valuesTestValidation': [*range(3, 8)]},
-	'A078591': {'valuesTestValidation': [*range(3, 10)]},
-	'A178961': {'valuesTestValidation': [*range(3, 11)]},
-	'A223094': {'valuesTestValidation': [*range(3, 11)]},
-	'A259702': {'valuesTestValidation': [*range(3, 13)]},
-	'A301620': {'valuesTestValidation': [*range(3, 11)]},
+OEISidManuallySet: dict[str, MetadataOEISidManuallySet] = {
+	'A000560': {'valuesTestValidation': [random.randint(3, 12)]},
+	'A000682': {'valuesTestValidation': [random.randint(3, 12), 32]},
+	'A001010': {'valuesTestValidation': [3, 4, random.randint(5, 11)]},
+	'A001011': {'valuesTestValidation': [3, 4, random.randint(5, 7)]},
+	'A005315': {'valuesTestValidation': [random.randint(3, 9)]},
+	'A005316': {'valuesTestValidation': [random.randint(3, 13)]},
+	'A007822': {'valuesTestValidation': [random.randint(2, 8)]}, #, 'valuesBenchmark': [7], 'valuesTestParallelization': [*range(2, 4)]},
+	'A060206': {'valuesTestValidation': [random.randint(3, 9)]},
+	'A077460': {'valuesTestValidation': [3, 4, random.randint(5, 8)]},
+	'A078591': {'valuesTestValidation': [random.randint(3, 10)]},
+	'A178961': {'valuesTestValidation': [random.randint(3, 11)]},
+	'A223094': {'valuesTestValidation': [random.randint(3, 11)]},
+	'A259702': {'valuesTestValidation': [random.randint(3, 13)]},
+	'A301620': {'valuesTestValidation': [random.randint(3, 11)]},
 }
 
 # Recreate packageSettings with meanders settings included
 packageSettings = mapFoldingPackageSettings(
 	identifierPackageFALLBACK=identifierPackageFALLBACK,
 	OEISidMapFoldingManuallySet=OEISidMapFoldingManuallySet,
-	OEISidMeandersManuallySet=OEISidMeandersManuallySet,
+	OEISidManuallySet=OEISidManuallySet,
 )
 """Global package settings."""
+
+# TODO integrate into packageSettings
+pathCache: Path = packageSettings.pathPackage / ".cache"

mapFolding/_theTypes.py

@@ -2,7 +2,8 @@
 
 from collections.abc import Callable
 from numpy import dtype, int_ as numpy_int, integer, ndarray, uint64 as numpy_uint64
-from typing import Any, TypeAlias, TypedDict, TypeVar
+from types import EllipsisType
+from typing import Any, Final, NamedTuple, TypeAlias, TypedDict, TypeVar
 
 NumPyIntegerType = TypeVar('NumPyIntegerType', bound=integer[Any], covariant=True)
 """Any NumPy integer type, which is usually between 8-bit signed and 64-bit unsigned."""
@@ -65,7 +66,7 @@ class MetadataOEISidMapFoldingManuallySet(TypedDict):
 	"""List of index values, 'n', to use when testing validation performance."""
 
 class MetadataOEISidMapFolding(TypedDict):
-	"""Settings for an implemented OEIS sequence."""
+	"""Settings for an OEIS ID that may be computed by a multidimensional map folding algorithm."""
 
 	description: str
 	"""The OEIS.org description of the integer sequence."""
@@ -85,7 +86,7 @@ class MetadataOEISidMapFolding(TypedDict):
 	"""The smallest value of 'n' for for which `foldsTotal` is unknown."""
 
 # ruff: noqa: ERA001
-class MetadataOEISidMeandersManuallySet(TypedDict):
+class MetadataOEISidManuallySet(TypedDict):
 	"""Settings that are best selected by a human instead of algorithmically."""
 
 	# valuesBenchmark: list[int]
@@ -95,7 +96,7 @@ class MetadataOEISidMeandersManuallySet(TypedDict):
 	valuesTestValidation: list[int]
 	"""List of index values, 'n', to use when testing validation performance."""
 
-class MetadataOEISidMeanders(TypedDict):
+class MetadataOEISid(TypedDict):
 	"""Settings for an implemented OEIS sequence."""
 
 	description: str
@@ -112,3 +113,19 @@ class MetadataOEISidMeanders(TypedDict):
 	"""List of index values, 'n', to use when testing validation performance."""
 	valueUnknown: int
 	"""The smallest value of 'n' for for which `foldsTotal` is unknown."""
+
+# TODO Figure out how to have a SSOT for the axis order.
+axisOfLength: Final[int] = 0
+
+class ShapeArray(NamedTuple):
+	"""Always use this to construct arrays, so you can reorder the axes merely by reordering this class."""
+
+	length: int
+	indices: int
+
+class ShapeSlicer(NamedTuple):
+	"""Always use this to construct slicers, so you can reorder the axes merely by reordering this class."""
+
+	length: EllipsisType | slice
+	indices: int
+