mapFolding 0.8.0__py3-none-any.whl → 0.8.1__py3-none-any.whl

mapFolding/__init__.py

@@ -1,9 +1,38 @@
+"""
+Map folding enumeration and counting algorithms with optimization capabilities.
+
+This package implements algorithms to count and enumerate the various 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 low-level 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: Utility functions for common operations and parameter management
+- theSSOT: Single Source of Truth for configuration, types, and state management
+- 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
+
+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
+
+This package strives to balance algorithm readability and understandability with
+high-performance computation capabilities, allowing users to compute map folding
+totals for larger dimensions than previously feasible.
+"""
 from mapFolding.basecamp import countFolds as countFolds
 from mapFolding.oeis import clearOEIScache, getOEISids, OEIS_for_n
 
 __all__ = [
-	'clearOEIScache',
-	'countFolds',
-	'getOEISids',
-	'OEIS_for_n',
+    'clearOEIScache',
+    'countFolds',
+    'getOEISids',
+    'OEIS_for_n',
 ]

mapFolding/basecamp.py

@@ -1,3 +1,17 @@
+"""
+Public API for the map folding algorithm with simplified interface.
+
+This module provides the main entry point for users of the mapFolding package,
+abstracting away the complexities of the computational algorithm. It offers
+a high-level interface to count the total number of possible ways to fold
+a rectangular map of specified dimensions, with options for customizing the
+computation process and saving results.
+
+The primary function is countFolds, which handles parameter validation,
+computation state management, dispatching to the appropriate algorithm
+implementation, and optional persistence of results.
+"""
+
 from collections.abc import Sequence
 from mapFolding.beDRY import outfitCountFolds, setCPUlimit, validateListDimensions
 from mapFolding.filesystem import getPathFilenameFoldsTotal, saveFoldsTotal

mapFolding/beDRY.py

@@ -1,4 +1,19 @@
-"""A relatively stable API for oft-needed functionality."""
+"""
+Utility functions for maintaining DRY (Don't Repeat Yourself) principles in the mapFolding package.
+
+This module provides a collection of helper functions that abstract common operations needed
+throughout the package, preventing code duplication and ensuring consistency. The functions
+manage core aspects of the computation process, including:
+
+1. Resource allocation and system limits management
+2. Data structure initialization and manipulation
+3. Parameter validation and interpretation
+4. Construction of specialized arrays and matrices for the folding algorithm
+
+The functions in this module serve as a relatively stable API for other modules to use,
+particularly for initializing computation state, validating inputs, and creating data
+structures needed by the folding algorithms.
+"""
 from collections.abc import Sequence
 from mapFolding.theSSOT import Array3D, ComputationState, getDatatypePackage, getNumpyDtypeDefault
 from sys import maxsize as sysMaxsize

mapFolding/filesystem.py

@@ -1,95 +1,129 @@
-"""Filesystem functions for mapFolding package."""
+"""
+Filesystem utilities for managing map folding computation results.
+
+This module provides functions for standardized handling of files related to the mapFolding
+package, with a focus on saving, retrieving, and naming computation results. It implements
+consistent naming conventions and path resolution strategies to ensure that:
+
+1. Computation results are stored in a predictable location
+2. Filenames follow a consistent pattern based on map dimensions
+3. Results can be reliably retrieved for future reference
+4. The system handles file operations safely with appropriate error handling
+
+The module serves as the interface between the computational components of the package
+and the filesystem, abstracting away the details of file operations and path management.
+"""
 from pathlib import Path, PurePath
 from typing import Any
+from os import PathLike
 import os
 
 def getFilenameFoldsTotal(mapShape: tuple[int, ...]) -> str:
-	"""Imagine your computer has been counting folds for 9 days, and when it tries to save your newly discovered value,
-	the filename is invalid. I bet you think this function is more important after that thought experiment.
-
-	Make a standardized filename for the computed value `foldsTotal`.
-
-	The filename takes into account
-		- the dimensions of the map, aka `mapShape`, aka `listDimensions`
-		- no spaces in the filename
-		- safe filesystem characters
-		- unique extension
-		- Python-safe strings:
-			- no starting with a number
-			- no reserved words
-			- no dashes or other special characters
-			- uh, I can't remember, but I found some other frustrating limitations
-		- if 'p' is still the first character of the filename, I picked that because it was the original identifier for the map shape in Lunnan's code
-
-	Parameters:
-		mapShape: A sequence of integers representing the dimensions of the map.
-
-	Returns:
-		filenameFoldsTotal: A filename string in format 'pMxN.foldsTotal' where M,N are sorted dimensions
-	"""
-	return 'p' + 'x'.join(str(dimension) for dimension in sorted(mapShape)) + '.foldsTotal'
-
-def getPathFilenameFoldsTotal(mapShape: tuple[int, ...], pathLikeWriteFoldsTotal: str | os.PathLike[str] | None = None) -> Path:
-	"""Get a standardized path and filename for the computed value `foldsTotal`.
-
-	If you provide a directory, the function will append a standardized filename. If you provide a filename
-	or a relative path and filename, the function will prepend the default path.
-
-	Parameters:
-		mapShape: List of dimensions for the map folding problem.
-		pathLikeWriteFoldsTotal (pathJobRootDEFAULT): Path, filename, or relative path and filename. If None, uses default path.
-			Defaults to None.
-
-	Returns:
-		pathFilenameFoldsTotal: Absolute path and filename.
-	"""
-	from mapFolding.theSSOT import getPathJobRootDEFAULT
-
-	if pathLikeWriteFoldsTotal is None:
-		pathFilenameFoldsTotal = getPathJobRootDEFAULT() / getFilenameFoldsTotal(mapShape)
-	else:
-		pathLikeSherpa = Path(pathLikeWriteFoldsTotal)
-		if pathLikeSherpa.is_dir():
-			pathFilenameFoldsTotal = pathLikeSherpa / getFilenameFoldsTotal(mapShape)
-		elif pathLikeSherpa.is_file() and pathLikeSherpa.is_absolute():
-			pathFilenameFoldsTotal = pathLikeSherpa
-		else:
-			pathFilenameFoldsTotal = getPathJobRootDEFAULT() / pathLikeSherpa
-
-	pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
-	return pathFilenameFoldsTotal
-
-def saveFoldsTotal(pathFilename: str | os.PathLike[str], foldsTotal: int) -> None:
-	"""
-	Save foldsTotal with multiple fallback mechanisms.
-
-	Parameters:
-		pathFilename: Target save location
-		foldsTotal: Critical computed value to save
-	"""
-	try:
-		pathFilenameFoldsTotal = Path(pathFilename)
-		pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
-		pathFilenameFoldsTotal.write_text(str(foldsTotal))
-	except Exception as ERRORmessage:
-		try:
-			print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
-			print(ERRORmessage)
-			print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
-			randomnessPlanB = (int(str(foldsTotal).strip()[-1]) + 1) * ['YO_']
-			filenameInfixUnique = ''.join(randomnessPlanB)
-			pathFilenamePlanB = os.path.join(os.getcwd(), 'foldsTotal' + filenameInfixUnique + '.txt')
-			writeStreamFallback = open(pathFilenamePlanB, 'w')
-			writeStreamFallback.write(str(foldsTotal))
-			writeStreamFallback.close()
-			print(str(pathFilenamePlanB))
-		except Exception:
-			print(foldsTotal)
-	return None
-
-def writeStringToHere(this: str, pathFilename: str | os.PathLike[Any] | PurePath) -> None:
-	"""Write the string `this` to the file at `pathFilename`."""
-	pathFilename = Path(pathFilename)
-	pathFilename.parent.mkdir(parents=True, exist_ok=True)
-	pathFilename.write_text(str(this))
-	return None
+    """
+    Create a standardized filename for a computed `foldsTotal` value.
+
+    This function generates a consistent, filesystem-safe filename based on map dimensions.
+    Standardizing filenames ensures that results can be reliably stored and retrieved,
+    avoiding potential filesystem incompatibilities or Python naming restrictions.
+
+    Parameters:
+        mapShape: A sequence of integers representing the dimensions of the map.
+
+    Returns:
+        filenameFoldsTotal: A filename string in format 'pMxN.foldsTotal' where M,N are sorted dimensions.
+
+    Notes:
+        The filename format ensures:
+        - No spaces in the filename
+        - Safe filesystem characters
+        - Unique extension (.foldsTotal)
+        - Python-safe strings (no starting with numbers, no reserved words)
+        - The 'p' prefix preserves compatibility with Lunnan's original code.
+    """
+    return 'p' + 'x'.join(str(dimension) for dimension in sorted(mapShape)) + '.foldsTotal'
+
+def getPathFilenameFoldsTotal(mapShape: tuple[int, ...], pathLikeWriteFoldsTotal: str | PathLike[str] | None = None) -> Path:
+    """
+    Get a standardized path and filename for the computed foldsTotal value.
+
+    This function resolves paths for storing computation results, handling different
+    input types including directories, absolute paths, or relative paths. It ensures
+    that all parent directories exist in the resulting path.
+
+    Parameters:
+        mapShape: List of dimensions for the map folding problem.
+        pathLikeWriteFoldsTotal (getPathJobRootDEFAULT): Path, filename, or relative path and filename.
+            If None, uses default path. If a directory, appends standardized filename.
+
+    Returns:
+        pathFilenameFoldsTotal: Absolute path and filename for storing the foldsTotal value.
+
+    Notes:
+        The function creates any necessary directories in the path if they don't exist.
+    """
+    from mapFolding.theSSOT import getPathJobRootDEFAULT
+
+    if pathLikeWriteFoldsTotal is None:
+        pathFilenameFoldsTotal = getPathJobRootDEFAULT() / getFilenameFoldsTotal(mapShape)
+    else:
+        pathLikeSherpa = Path(pathLikeWriteFoldsTotal)
+        if pathLikeSherpa.is_dir():
+            pathFilenameFoldsTotal = pathLikeSherpa / getFilenameFoldsTotal(mapShape)
+        elif pathLikeSherpa.is_file() and pathLikeSherpa.is_absolute():
+            pathFilenameFoldsTotal = pathLikeSherpa
+        else:
+            pathFilenameFoldsTotal = getPathJobRootDEFAULT() / pathLikeSherpa
+
+    pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
+    return pathFilenameFoldsTotal
+
+def saveFoldsTotal(pathFilename: str | PathLike[str], foldsTotal: int) -> None:
+    """
+    Save `foldsTotal` value to disk with multiple fallback mechanisms.
+
+    This function attempts to save the computed `foldsTotal` value to the specified
+    location, with backup strategies in case the primary save attempt fails.
+    The robustness is critical since these computations may take days to complete.
+
+    Parameters:
+        pathFilename: Target save location for the `foldsTotal` value
+        foldsTotal: The computed value to save
+
+    Notes:
+        If the primary save fails, the function will attempt alternative save methods:
+        1. Print the value prominently to stdout
+        2. Create a fallback file in the current working directory
+        3. As a last resort, simply print the value
+    """
+    try:
+        pathFilenameFoldsTotal = Path(pathFilename)
+        pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
+        pathFilenameFoldsTotal.write_text(str(foldsTotal))
+    except Exception as ERRORmessage:
+        try:
+            print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
+            print(ERRORmessage)
+            print(f"\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n\n{foldsTotal=}\n\nfoldsTotal foldsTotal foldsTotal foldsTotal foldsTotal\n")
+            randomnessPlanB = (int(str(foldsTotal).strip()[-1]) + 1) * ['YO_']
+            filenameInfixUnique = ''.join(randomnessPlanB)
+            pathFilenamePlanB = os.path.join(os.getcwd(), 'foldsTotal' + filenameInfixUnique + '.txt')
+            writeStreamFallback = open(pathFilenamePlanB, 'w')
+            writeStreamFallback.write(str(foldsTotal))
+            writeStreamFallback.close()
+            print(str(pathFilenamePlanB))
+        except Exception:
+            print(foldsTotal)
+    return None
+
+def writeStringToHere(this: str, pathFilename: str | PathLike[Any] | PurePath) -> None:
+    """
+    Write a string to a file, creating parent directories if needed.
+
+    Parameters:
+        this: The string content to write to the file
+        pathFilename: The target file path where the string should be written
+    """
+    pathFilename = Path(pathFilename)
+    pathFilename.parent.mkdir(parents=True, exist_ok=True)
+    pathFilename.write_text(str(this))
+    return None

mapFolding/noHomeYet.py

@@ -1,3 +1,15 @@
+"""
+Interface for retrieving known map folding totals from OEIS (Online Encyclopedia of Integer Sequences).
+
+This module provides utilities for accessing pre-computed map folding totals that are known
+from mathematical literature and stored in the OEIS. The functions cache results for
+performance and provide lookups based on map dimensions.
+
+The main functions are:
+- makeDictionaryFoldsTotalKnown: Creates a dictionary of known folding totals indexed by map dimensions
+- getFoldsTotalKnown: Retrieves the folding total for a specific map shape, returning -1 if unknown
+"""
+
 from functools import cache
 from mapFolding.oeis import settingsOEIS
 

mapFolding/oeis.py

@@ -1,4 +1,19 @@
-"""Everything implementing the The Online Encyclopedia of Integer Sequences (OEIS); _only_ things that implement _only_ the OEIS."""
+"""
+Interface to The Online Encyclopedia of Integer Sequences (OEIS) for map folding sequences.
+
+This module provides a comprehensive interface for accessing and utilizing integer sequences
+from the OEIS that relate to map folding problems. It implements functionality to:
+
+1. Retrieve sequence data from OEIS with local caching for performance
+2. Map sequence indices to corresponding map shapes based on sequence definitions
+3. Provide a command-line interface for sequence lookups
+4. Execute map folding computations for sequence terms not available in OEIS
+
+The module maintains a registry of implemented OEIS sequences (A001415-A001418, A195646)
+with their metadata, known values, and functions to convert between sequence indices and
+map dimensions. This allows the package to validate results against established mathematical
+literature and extend sequences beyond their currently known terms.
+"""
 from collections.abc import Callable
 from datetime import datetime, timedelta
 from mapFolding.theSSOT import thePathPackage

mapFolding/reference/flattened.py

@@ -1,14 +1,15 @@
 """The algorithm flattened into semantic sections.
 This version is not maintained, so you may see differences from the current version."""
+from collections.abc import Sequence
 from numpy import integer
 from numpy.typing import NDArray
-from typing import List, Any, Final, Optional, Union, Sequence, Tuple, Type, TypedDict
+from typing import Any, Final, TypedDict
 import enum
 import numpy
 import sys
 
-def countFolds(listDimensions: Sequence[int], computationDivisions = None, CPUlimit: Optional[Union[int, float, bool]] = None):
-	def doWhile():
+def countFolds(listDimensions: Sequence[int], computationDivisions: int | str | None = None, CPUlimit: int | float | bool | None = None) -> int:
+	def doWhile() -> None:
 
 		while activeLeafGreaterThan0Condition():
 
@@ -49,99 +50,99 @@ def countFolds(listDimensions: Sequence[int], computationDivisions = None, CPUli
 			if placeLeafCondition():
 				placeLeaf()
 
-	def activeGapIncrement():
+	def activeGapIncrement() -> None:
 		my[indexMy.gap1ndex] += 1
 
-	def activeLeafGreaterThan0Condition():
+	def activeLeafGreaterThan0Condition() -> bool:
 		return my[indexMy.leaf1ndex] > 0
 
-	def activeLeafGreaterThanLeavesTotalCondition():
+	def activeLeafGreaterThanLeavesTotalCondition() -> bool:
 		return my[indexMy.leaf1ndex] > the[indexThe.leavesTotal]
 
-	def activeLeafIsTheFirstLeafCondition():
+	def activeLeafIsTheFirstLeafCondition() -> bool:
 		return my[indexMy.leaf1ndex] <= 1
 
-	def activeLeafNotEqualToTaskDivisionsCondition():
+	def activeLeafNotEqualToTaskDivisionsCondition() -> bool:
 		return my[indexMy.leaf1ndex] != the[indexThe.taskDivisions]
 
-	def allDimensionsAreUnconstrained():
+	def allDimensionsAreUnconstrained() -> bool:
 		return my[indexMy.dimensionsUnconstrained] == the[indexThe.dimensionsTotal]
 
-	def backtrack():
+	def backtrack() -> None:
 		my[indexMy.leaf1ndex] -= 1
 		track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]] = track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]
 		track[indexTrack.leafAbove, track[indexTrack.leafBelow, my[indexMy.leaf1ndex]]] = track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]
 
-	def backtrackCondition():
+	def backtrackCondition() -> bool:
 		return my[indexMy.leaf1ndex] > 0 and my[indexMy.gap1ndex] == track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex] - 1]
 
-	def computationDivisionsCondition():
+	def computationDivisionsCondition() -> bool:
 		return the[indexThe.taskDivisions] == int(False)
 
-	def countGaps():
+	def countGaps() -> None:
 		gapsWhere[my[indexMy.gap1ndexCeiling]] = my[indexMy.leafConnectee]
 		if track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] == 0:
 			gap1ndexCeilingIncrement()
 		track[indexTrack.countDimensionsGapped, my[indexMy.leafConnectee]] += 1
 
-	def dimension1ndexIncrement():
+	def dimension1ndexIncrement() -> None:
 		my[indexMy.dimension1ndex] += 1
 
-	def dimensionsUnconstrainedCondition():
+	def dimensionsUnconstrainedCondition() -> bool:
 		return connectionGraph[my[indexMy.dimension1ndex], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]] == my[indexMy.leaf1ndex]
 
-	def dimensionsUnconstrainedIncrement():
+	def dimensionsUnconstrainedIncrement() -> None:
 		my[indexMy.dimensionsUnconstrained] += 1
 
-	def filterCommonGaps():
+	def filterCommonGaps() -> None:
 		gapsWhere[my[indexMy.gap1ndex]] = gapsWhere[my[indexMy.indexMiniGap]]
 		if track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] == the[indexThe.dimensionsTotal] - my[indexMy.dimensionsUnconstrained]:
 			activeGapIncrement()
 		track[indexTrack.countDimensionsGapped, gapsWhere[my[indexMy.indexMiniGap]]] = 0
 
-	def findGapsInitializeVariables():
+	def findGapsInitializeVariables() -> None:
 		my[indexMy.dimensionsUnconstrained] = 0
 		my[indexMy.gap1ndexCeiling] = track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex] - 1]
 		my[indexMy.dimension1ndex] = 1
 
-	def foldsSubTotalsIncrement():
+	def foldsSubTotalsIncrement() -> None:
 		foldsSubTotals[my[indexMy.taskIndex]] += the[indexThe.leavesTotal]
 
-	def gap1ndexCeilingIncrement():
+	def gap1ndexCeilingIncrement() -> None:
 		my[indexMy.gap1ndexCeiling] += 1
 
-	def indexMiniGapIncrement():
+	def indexMiniGapIncrement() -> None:
 		my[indexMy.indexMiniGap] += 1
 
-	def indexMiniGapInitialization():
+	def indexMiniGapInitialization() -> None:
 		my[indexMy.indexMiniGap] = my[indexMy.gap1ndex]
 
-	def insertUnconstrainedLeaf():
+	def insertUnconstrainedLeaf() -> None:
 		my[indexMy.indexLeaf] = 0
 		while my[indexMy.indexLeaf] < my[indexMy.leaf1ndex]:
 			gapsWhere[my[indexMy.gap1ndexCeiling]] = my[indexMy.indexLeaf]
 			my[indexMy.gap1ndexCeiling] += 1
 			my[indexMy.indexLeaf] += 1
 
-	def leafBelowSentinelIs1Condition():
+	def leafBelowSentinelIs1Condition() -> bool:
 		return track[indexTrack.leafBelow, 0] == 1
 
-	def leafConnecteeInitialization():
+	def leafConnecteeInitialization() -> None:
 		my[indexMy.leafConnectee] = connectionGraph[my[indexMy.dimension1ndex], my[indexMy.leaf1ndex], my[indexMy.leaf1ndex]]
 
-	def leafConnecteeUpdate():
+	def leafConnecteeUpdate() -> None:
 		my[indexMy.leafConnectee] = connectionGraph[my[indexMy.dimension1ndex], my[indexMy.leaf1ndex], track[indexTrack.leafBelow, my[indexMy.leafConnectee]]]
 
-	def loopingLeavesConnectedToActiveLeaf():
+	def loopingLeavesConnectedToActiveLeaf() -> bool:
 		return my[indexMy.leafConnectee] != my[indexMy.leaf1ndex]
 
-	def loopingTheDimensions():
+	def loopingTheDimensions() -> bool:
 		return my[indexMy.dimension1ndex] <= the[indexThe.dimensionsTotal]
 
-	def loopingToActiveGapCeiling():
+	def loopingToActiveGapCeiling() -> bool:
 		return my[indexMy.indexMiniGap] < my[indexMy.gap1ndexCeiling]
 
-	def placeLeaf():
+	def placeLeaf() -> None:
 		my[indexMy.gap1ndex] -= 1
 		track[indexTrack.leafAbove, my[indexMy.leaf1ndex]] = gapsWhere[my[indexMy.gap1ndex]]
 		track[indexTrack.leafBelow, my[indexMy.leaf1ndex]] = track[indexTrack.leafBelow, track[indexTrack.leafAbove, my[indexMy.leaf1ndex]]]
@@ -150,13 +151,13 @@ def countFolds(listDimensions: Sequence[int], computationDivisions = None, CPUli
 		track[indexTrack.gapRangeStart, my[indexMy.leaf1ndex]] = my[indexMy.gap1ndex]
 		my[indexMy.leaf1ndex] += 1
 
-	def placeLeafCondition():
+	def placeLeafCondition() -> bool:
 		return my[indexMy.leaf1ndex] > 0
 
-	def taskIndexCondition():
+	def taskIndexCondition() -> bool:
 		return my[indexMy.leafConnectee] % the[indexThe.taskDivisions] == my[indexMy.taskIndex]
 
-	def thereAreComputationDivisionsYouMightSkip():
+	def thereAreComputationDivisionsYouMightSkip() -> bool:
 		if computationDivisionsCondition():
 			return True
 		if activeLeafNotEqualToTaskDivisionsCondition():
@@ -166,11 +167,11 @@ def countFolds(listDimensions: Sequence[int], computationDivisions = None, CPUli
 		return False
 
 	stateUniversal = outfitFoldings(listDimensions, computationDivisions=computationDivisions, CPUlimit=CPUlimit)
-	connectionGraph: Final[numpy.ndarray] = stateUniversal['connectionGraph']
+	connectionGraph: Final[NDArray[numpy.integer[Any]]] = stateUniversal['connectionGraph']
 	foldsSubTotals = stateUniversal['foldsSubTotals']
 	gapsWhere = stateUniversal['gapsWhere']
 	my = stateUniversal['my']
-	the: Final[numpy.ndarray] = stateUniversal['the']
+	the: Final[NDArray[numpy.integer[Any]]] = stateUniversal['the']
 	track = stateUniversal['track']
 
 	if the[indexThe.taskDivisions] == int(False):
@@ -192,7 +193,7 @@ def countFolds(listDimensions: Sequence[int], computationDivisions = None, CPUli
 class EnumIndices(enum.IntEnum):
 	"""Base class for index enums."""
 	@staticmethod
-	def _generate_next_value_(name, start, count, last_values):
+	def _generate_next_value_(name: str, start: int, count: int, last_values: list[int]) -> int:
 		"""0-indexed."""
 		return count
 
@@ -229,7 +230,7 @@ class indexTrack(EnumIndices):
 class computationState(TypedDict):
 	connectionGraph: NDArray[integer[Any]]
 	foldsSubTotals: NDArray[integer[Any]]
-	mapShape: Tuple[int, ...]
+	mapShape: tuple[int, ...]
 	my: NDArray[integer[Any]]
 	gapsWhere: NDArray[integer[Any]]
 	the: NDArray[integer[Any]]
@@ -262,7 +263,7 @@ def getLeavesTotal(listDimensions: Sequence[int]) -> int:
 
 		return productDimensions
 
-def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrencyLimit: int, CPUlimit: Optional[Union[bool, float, int]], listDimensions: Sequence[int]):
+def getTaskDivisions(computationDivisions: int | str | None, concurrencyLimit: int, CPUlimit: bool | float | int | None, listDimensions: Sequence[int]) -> int:
 	if not computationDivisions:
 		return 0
 	else:
@@ -284,7 +285,7 @@ def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrenc
 
 	return taskDivisions
 
-def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optional[Type]) -> NDArray[integer[Any]]:
+def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: type | None) -> NDArray[integer[Any]]:
 	datatype = keywordArguments.get('datatype', dtypeMedium)
 	mapShape = validateListDimensions(listDimensions)
 	leavesTotal = getLeavesTotal(mapShape)
@@ -316,12 +317,12 @@ def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optio
 					connectionGraph[dimension1ndex, activeLeaf1ndex, connectee1ndex] = connectee1ndex
 	return connectionGraph
 
-def makeDataContainer(shape, datatype: Optional[Type] = None):
+def makeDataContainer(shape: int | Sequence[int], datatype: type | None = None) -> NDArray[integer[Any]]:
 	if datatype is None:
 		datatype = dtypeMedium
 	return numpy.zeros(shape, dtype=datatype)
 
-def outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, **keywordArguments: Optional[Type]) -> computationState:
+def outfitFoldings(listDimensions: Sequence[int], computationDivisions: int | str | None = None, CPUlimit: bool | float | int | None = None, **keywordArguments: type | None) -> computationState:
 	datatypeMedium = keywordArguments.get('datatypeMedium', dtypeMedium)
 	datatypeLarge = keywordArguments.get('datatypeLarge', dtypeLarge)
 
@@ -346,10 +347,10 @@ def outfitFoldings(listDimensions: Sequence[int], computationDivisions: Optional
 	stateInitialized['my'][indexMy.leaf1ndex] = 1
 	return stateInitialized
 
-def parseDimensions(dimensions: Sequence[int], parameterName: str = 'unnamed parameter') -> List[int]:
+def parseDimensions(dimensions: Sequence[int], parameterName: str = 'unnamed parameter') -> list[int]:
 	# listValidated = intInnit(dimensions, parameterName)
 	listNOTValidated = dimensions if isinstance(dimensions, (list, tuple)) else list(dimensions)
-	listNonNegative = []
+	listNonNegative: list[int] = []
 	for dimension in listNOTValidated:
 		if dimension < 0:
 			raise ValueError(f"Dimension {dimension} must be non-negative")
@@ -358,7 +359,7 @@ def parseDimensions(dimensions: Sequence[int], parameterName: str = 'unnamed par
 		raise ValueError("At least one dimension must be non-negative")
 	return listNonNegative
 
-def setCPUlimit(CPUlimit: Union[bool, float, int, None]) -> int:
+def setCPUlimit(CPUlimit: bool | float | int | None) -> int:
 	# if not (CPUlimit is None or isinstance(CPUlimit, (bool, int, float))):
 	#	 CPUlimit = oopsieKwargsie(CPUlimit)
 	# concurrencyLimit = defineConcurrencyLimit(CPUlimit)
@@ -367,7 +368,7 @@ def setCPUlimit(CPUlimit: Union[bool, float, int, None]) -> int:
 	concurrencyLimit = concurrencyLimitHARDCODED
 	return concurrencyLimit
 
-def validateListDimensions(listDimensions: Sequence[int]) -> List[int]:
+def validateListDimensions(listDimensions: Sequence[int]) -> list[int]:
 	if not listDimensions:
 		raise ValueError(f"listDimensions is a required parameter.")
 	listNonNegative = parseDimensions(listDimensions, 'listDimensions')

mapFolding/reference/hunterNumba.py

@@ -1,9 +1,9 @@
-from typing import List
+from typing import Any
 import numba
 import numpy
 
 @numba.jit(cache=True, nopython=True, fastmath=True)
-def countFolds(listDimensions: List[int]) -> int:
+def countFolds(listDimensions: list[int]) -> int:
 	"""
 	Count the number of distinct ways to fold a map with at least two positive dimensions.
 
@@ -13,10 +13,10 @@ def countFolds(listDimensions: List[int]) -> int:
 	Returns:
 		foldsTotal: The total number of distinct folds for the given map dimensions.
 	"""
-	def integerSmall(value) -> numpy.uint8:
+	def integerSmall(value: numpy.integer[Any] | Any) -> numpy.uint8:
 		return numpy.uint8(value)
 
-	def integerLarge(value) -> numpy.uint64:
+	def integerLarge(value: numpy.integer[Any] | Any) -> numpy.uint64:
 		return numpy.uint64(value)
 
 	dtypeMedium = numpy.uint8

mapFolding/reference/irvineJavaPort.py

@@ -2,7 +2,7 @@
 Ported from the Java version by Sean A. Irvine:
 https://github.com/archmageirvine/joeis/blob/80e3e844b11f149704acbab520bc3a3a25ac34ff/src/irvine/oeis/a001/A001415.java
 
-Citation: mapFolding/citations/jOEIS.bibtex
+Citation: https://github.com/hunterhogan/mapFolding/blob/134f2e6ecdf59fb6f6829c775475544a6aaaa800/citations/jOEIS.bibtex
 """
 def foldings(p: list[int], res: int = 0, mod: int = 0) -> int:
 	"""