mapFolding 0.15.4__tar.gz → 0.16.1__tar.gz

mapfolding-0.16.1/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: mapFolding
+Version: 0.16.1
+Summary: Map folding, meanders, stamp folding, semi-meanders. Experiment with algorithm transformations, and analyze computational states.
+Author-email: Hunter Hogan <HunterHogan@pm.me>
+License: CC-BY-NC-4.0
+Project-URL: Donate, https://www.patreon.com/integrated
+Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
+Project-URL: Issues, https://github.com/hunterhogan/mapFolding/issues
+Project-URL: Repository, https://github.com/hunterhogan/mapFolding.git
+Keywords: A000136,A000560,A000682,A001010,A001011,A001415,A001416,A001417,A001418,A005315,A005316,A007822,A178961,A195646,A223094,A259702,A301620,AST manipulation,JIT compilation,Numba optimization,OEIS,Python optimization,abstract syntax tree,algorithmic combinatorics,algorithmic optimization,arch configurations,automated code generation,bit-packed arrays,bitwise state machines,cache-efficient algorithms,closed meandric numbers,code generation,code optimization,code synthesis,code transformation,codon optimization,combinatorial computing,combinatorial enumeration,combinatorial geometry,combinatorial mathematics,combinatorial problem solver,combinatorics,computational combinatorics,computational geometry,crossing patterns,curve crossings,dataclass transformation,discrete mathematics,dynamic compilation,enumerative combinatorics,folding pattern enumeration,folding problems,high-performance computing,integer sequences,just-in-time compilation,kernel optimization,labeled stamp folding,low-level computation,map folding,mapFolding,mathematical algorithms,mathematical modeling,mathematical optimization,mathematical patterns,mathematical software,mathematical tool,mathematical visualization,meander enumeration,meanders,meandric systems,memory-efficient enumeration,metaprogramming,numerical algorithms,numerical computation,open meandric systems,paper folding mathematics,parallel computing,pattern recognition,performance optimization,permutation patterns,permutations,post-setup optimization,pyproject,scientific computing,semi-meanders,sequence analysis,sequence calculator,sequence enumeration,sequence explorer,sequence generation,source code analysis,stamp folding,symbolic computation,symmetric foldings,topological combinatorics,topological patterns,typed Python
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Natural Language :: English
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Pre-processors
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: astToolkit
+Requires-Dist: autoflake
+Requires-Dist: hunterMakesPy
+Requires-Dist: isort
+Requires-Dist: numpy
+Requires-Dist: platformdirs
+Provides-Extra: development
+Requires-Dist: memray; sys_platform == "linux" and extra == "development"
+Requires-Dist: mypy; extra == "development"
+Requires-Dist: pyupgrade; extra == "development"
+Requires-Dist: py-spy; extra == "development"
+Requires-Dist: setuptools-scm; extra == "development"
+Provides-Extra: numba
+Requires-Dist: numba; extra == "numba"
+Requires-Dist: numba_progress; extra == "numba"
+Provides-Extra: pandas
+Requires-Dist: pandas; extra == "pandas"
+Requires-Dist: pyarrow; extra == "pandas"
+Requires-Dist: pyarrow-stubs; extra == "pandas"
+Provides-Extra: testing
+Requires-Dist: numba; extra == "testing"
+Requires-Dist: pandas; extra == "testing"
+Requires-Dist: pyarrow; extra == "testing"
+Requires-Dist: pytest-cov; extra == "testing"
+Requires-Dist: pytest-env; extra == "testing"
+Requires-Dist: pytest-xdist; extra == "testing"
+Requires-Dist: pytest; extra == "testing"
+Dynamic: license-file
+
+# mapFolding
+
+[![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/)
+
+Map folding, meanders, stamp folding, semi-meanders. Experiment with algorithm transformations and code optimization.
+
+I don't know how to write a README.md. Furthermore, the package used to be focused on multidimensional map folding and tools for transforming the algorithm to experiment with optimizations or to explore the algorithm.
+
+First, the tools for transforming algorithms became far more sophisticated and powerful than this package. So I moved them to [astToolkit](https://github.com/hunterhogan/astToolkit). But those got so sophisticated, that I create more than half of that package through another layer of meta-programming: [astToolFactory](https://github.com/hunterhogan/astToolFactory).
+
+Second, when I finally understood the connections between map folding and meanders, I added meanders to this package, and applied my transformation tools to that algorithm.
+
+I used a weaker form of this package to [compute new terms for OEIS A001415](https://oeis.org/A001415), "Number of ways of folding a 2 X n strip of stamps."
+There are cool and powerful tools in here, but as of 2025 September 17, I am dissatisfied with the organization and documentation. It's annoying.
+
+## Finding stuff
+
+1. At the moment, almost every algorithm version eventually runs through "mapFolding/basecamp.py", so it's sort of an overview and you can work backwards to find more details.
+2. The directory "mapFolding/algorithms" only has "handmade" algorithms. Therefore, most logic for most computations is based on something in that directory.
+3. The directory "mapFolding/syntheticModules" has code that is generated by the transformation tools.
+4. Transformation functions are in "mapFolding/someAssemblyRequired."
+5. The directory "mapFolding/reference" has "reference" materials.
+6. "mapFolding/tests" has the tests, and I have tried to make it easy for you to add _your_ versions of the algorithms to the tests. Is it actually easy? I'll say it this way: if you were to create your own subclass of `ast.AST` it would be impossible for you to add your subclass to all of the `ast` module tests with just a few lines of code. In contrast, it is possible to fully test your algorithm with in my tests by adding between three and 25 lines of code. So, yeah, it's easy.
+
+## Math and programming
+
+I'm not a mathematician. I don't have training in or professional experience as a programmer. I'm not stupid: I'm ignorant.
+
+## My recovery
+
+[![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
+[![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)
+
+[![CC-BY-NC-4.0](https://github.com/hunterhogan/mapFolding/blob/main/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)

mapfolding-0.16.1/README.md

@@ -0,0 +1,34 @@
+# mapFolding
+
+[![pip install mapFolding](https://img.shields.io/badge/pip%20install-mapFolding-gray.svg?colorB=3b434b)](https://pypi.org/project/mapFolding/)
+
+Map folding, meanders, stamp folding, semi-meanders. Experiment with algorithm transformations and code optimization.
+
+I don't know how to write a README.md. Furthermore, the package used to be focused on multidimensional map folding and tools for transforming the algorithm to experiment with optimizations or to explore the algorithm.
+
+First, the tools for transforming algorithms became far more sophisticated and powerful than this package. So I moved them to [astToolkit](https://github.com/hunterhogan/astToolkit). But those got so sophisticated, that I create more than half of that package through another layer of meta-programming: [astToolFactory](https://github.com/hunterhogan/astToolFactory).
+
+Second, when I finally understood the connections between map folding and meanders, I added meanders to this package, and applied my transformation tools to that algorithm.
+
+I used a weaker form of this package to [compute new terms for OEIS A001415](https://oeis.org/A001415), "Number of ways of folding a 2 X n strip of stamps."
+There are cool and powerful tools in here, but as of 2025 September 17, I am dissatisfied with the organization and documentation. It's annoying.
+
+## Finding stuff
+
+1. At the moment, almost every algorithm version eventually runs through "mapFolding/basecamp.py", so it's sort of an overview and you can work backwards to find more details.
+2. The directory "mapFolding/algorithms" only has "handmade" algorithms. Therefore, most logic for most computations is based on something in that directory.
+3. The directory "mapFolding/syntheticModules" has code that is generated by the transformation tools.
+4. Transformation functions are in "mapFolding/someAssemblyRequired."
+5. The directory "mapFolding/reference" has "reference" materials.
+6. "mapFolding/tests" has the tests, and I have tried to make it easy for you to add _your_ versions of the algorithms to the tests. Is it actually easy? I'll say it this way: if you were to create your own subclass of `ast.AST` it would be impossible for you to add your subclass to all of the `ast` module tests with just a few lines of code. In contrast, it is possible to fully test your algorithm with in my tests by adding between three and 25 lines of code. So, yeah, it's easy.
+
+## Math and programming
+
+I'm not a mathematician. I don't have training in or professional experience as a programmer. I'm not stupid: I'm ignorant.
+
+## My recovery
+
+[![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
+[![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)
+
+[![CC-BY-NC-4.0](https://github.com/hunterhogan/mapFolding/blob/main/CC-BY-NC-4.0.png)](https://creativecommons.org/licenses/by-nc/4.0/)

mapfolding-0.16.1/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 && py Z0Z_A000682.py && title I'm done || title Error
+"""

mapfolding-0.16.1/easyRun/A005316.py

@@ -0,0 +1,21 @@
+# ruff: noqa
+# pyright: basic
+from mapFolding.basecamp import A005316
+import warnings
+
+warnings.filterwarnings("ignore", category=FutureWarning)
+
+n=25
+print(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
+title running && py Z0Z_A005316.py && title I'm done || title Error
+
+"""

mapfolding-0.16.1/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 = 'asynchronousTrimmed'
+	flow = 'asynchronous'
+	flow = 'asynchronousNumba'
+	flow = 'algorithm'
+	flow = 'theorem2Numba'
+
+	for n in range(5,11):
+
+		timeStart = time.perf_counter()
+		countTotal = NOTcountingFolds(oeisID, n, flow, CPUlimit)
+
+		_write()

mapfolding-0.16.1/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()

mapfolding-0.16.1/easyRun/meanders.py

@@ -0,0 +1,71 @@
+# 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 = 'matrixPandas'
+	flow = 'matrixMeanders'
+	flow = 'matrixNumPy'
+
+	for oeisID in [
+			'A005316',
+			'A000682',
+				]:
+		sys.stdout.write(f"\n{oeisID}\n")
+
+		"""TODO Identifiers. improve
+		kOfMatrix: I don't think the paper uses 'k'. step?
+
+		ReidemeisterMove?
+		flipTheExtra_0b1AsUfunc: what is extra?
+
+		"strand" is an interesting word.
+		"""
+
+		# for n in range(44,45):
+
+		# for n in range(43,56):
+		# for n in range(46,47):
+		# for n in range(43,47):
+		# for n in range(38,43):
+		# for n in range(28,38):
+		# for n in [*range(2, 10), *range(28,33)]:
+		# for n in range(28,33):
+		# for n in range(2, 28):
+		# for n in range(2, 10):
+		for n in range(1, 6):
+
+			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 && py Z0Z_aOFn.py && title I'm done || title Error
+
+"""

mapfolding-0.16.1/mapFolding/__init__.py

@@ -0,0 +1,48 @@
+"""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,
+	NumPyElephino as NumPyElephino,
+	NumPyFoldsTotal as NumPyFoldsTotal,
+	NumPyIntegerType as NumPyIntegerType,
+	NumPyLeavesTotal as NumPyLeavesTotal,
+	ShapeArray as ShapeArray,
+	ShapeSlicer as ShapeSlicer)
+
+from mapFolding._theSSOT import packageSettings as packageSettings
+
+from mapFolding.beDRY import (
+	getConnectionGraph as getConnectionGraph,
+	getLeavesTotal as getLeavesTotal,
+	getTaskDivisions as getTaskDivisions,
+	makeDataContainer as makeDataContainer,
+	setProcessorLimit as setProcessorLimit,
+	validateListDimensions as validateListDimensions)
+
+from mapFolding.filesystemToolkit import (
+	getFilenameFoldsTotal as getFilenameFoldsTotal,
+	getPathFilenameFoldsTotal as getPathFilenameFoldsTotal,
+	getPathRootJobDEFAULT as getPathRootJobDEFAULT,
+	saveFoldsTotal as saveFoldsTotal,
+	saveFoldsTotalFAILearly as saveFoldsTotalFAILearly)
+
+from mapFolding.basecamp import countFolds as countFolds
+
+from mapFolding.oeis import (
+	dictionaryOEIS as dictionaryOEIS,
+	dictionaryOEISMapFolding as dictionaryOEISMapFolding,
+	getFoldsTotalKnown as getFoldsTotalKnown,
+	getOEISids as getOEISids,
+	OEIS_for_n as OEIS_for_n,
+	oeisIDfor_n as oeisIDfor_n)

mapfolding-0.16.1/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-0.15.4 → mapfolding-0.16.1}/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,28 +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)]},
-	'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-0.15.4 → mapfolding-0.16.1}/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
+

{mapfolding-0.15.4 → mapfolding-0.16.1}/mapFolding/algorithms/daoOfMapFolding.py

@@ -1,4 +1,3 @@
-# ruff: noqa: D100 D103
 from mapFolding.dataBaskets import MapFoldingState
 
 def activeLeafGreaterThan0(state: MapFoldingState) -> bool:
@@ -140,4 +139,4 @@ def count(state: MapFoldingState) -> MapFoldingState:
 
 def doTheNeedful(state: MapFoldingState) -> MapFoldingState:
 	state = count(state)
-	return state  # noqa: RET504
+	return state