mapFolding 0.4.3__py3-none-any.whl → 0.5.0__py3-none-any.whl

mapFolding/__init__.py

@@ -61,7 +61,7 @@ from mapFolding.beDRY import (
 from mapFolding.basecamp import countFolds
 from mapFolding.oeis import clearOEIScache, getOEISids, oeisIDfor_n
 
-__all__ = [
+__all__: list[str] = [
 	'clearOEIScache',
 	'countFolds',
 	'getOEISids',

mapFolding/basecamp.py

@@ -1,12 +1,13 @@
+from collections.abc import Sequence
 from mapFolding import computationState, getDispatcherCallable, getPathFilenameFoldsTotal, outfitCountFolds, saveFoldsTotal
-from typing import Optional, Sequence, Union
-import os
-
-def countFolds(listDimensions: Sequence[int]
-				, pathLikeWriteFoldsTotal: Optional[Union[str, os.PathLike[str]]] = None
-				, computationDivisions: Optional[Union[int, str]] = None
-				, CPUlimit: Optional[Union[int, float, bool]] = None
-				, **keywordArguments: Optional[Union[str, bool]]
+from os import PathLike
+from pathlib import Path
+
+def countFolds(listDimensions: Sequence[int],
+				pathLikeWriteFoldsTotal: str | PathLike[str] | None = None,
+				computationDivisions: int | str | None = None,
+				CPUlimit: int | float | bool | None = None,
+				**keywordArguments: str | bool
 				) -> int:
 	"""Count the total number of possible foldings for a given map dimensions.
 
@@ -40,16 +41,13 @@ def countFolds(listDimensions: Sequence[int]
 	"""
 	stateUniversal: computationState = outfitCountFolds(listDimensions, computationDivisions=computationDivisions, CPUlimit=CPUlimit, **keywordArguments)
 
-	pathFilenameFoldsTotal = None
-	if pathLikeWriteFoldsTotal is not None:
-		pathFilenameFoldsTotal = getPathFilenameFoldsTotal(stateUniversal['mapShape'], pathLikeWriteFoldsTotal)
-
 	dispatcher = getDispatcherCallable()
 	dispatcher(**stateUniversal)
 
 	foldsTotal = int(stateUniversal['foldGroups'][0:-1].sum() * stateUniversal['foldGroups'][-1])
 
-	if pathFilenameFoldsTotal is not None:
+	if pathLikeWriteFoldsTotal is not None:
+		pathFilenameFoldsTotal: Path = getPathFilenameFoldsTotal(stateUniversal['mapShape'], pathLikeWriteFoldsTotal)
 		saveFoldsTotal(pathFilenameFoldsTotal, foldsTotal)
 
 	return foldsTotal

mapFolding/beDRY.py

@@ -12,17 +12,18 @@ from mapFolding import (
 	setDatatypeLeavesTotal,
 	setDatatypeModule,
 )
+from collections.abc import Sequence
+from numba import get_num_threads, set_num_threads
 from numpy import dtype, integer, ndarray
 from numpy.typing import DTypeLike, NDArray
-from typing import Any, List, Optional, Sequence, Tuple, Union
+from pathlib import Path
+from sys import maxsize as sysMaxsize
+from typing import Any
 from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
-import numba
 import numpy
 import os
-import pathlib
-import sys
 
-def getFilenameFoldsTotal(mapShape: Union[Sequence[int], ndarray[Tuple[int], dtype[integer[Any]]]]) -> str:
+def getFilenameFoldsTotal(mapShape: Sequence[int] | ndarray[tuple[int], dtype[integer[Any]]]) -> str:
 	"""Imagine your computer has been counting folds for 70 hours, 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.
 
@@ -66,13 +67,13 @@ def getLeavesTotal(listDimensions: Sequence[int]) -> int:
 	else:
 		productDimensions = 1
 		for dimension in listPositive:
-			if dimension > sys.maxsize // productDimensions:
+			if dimension > sysMaxsize // productDimensions:
 				raise OverflowError(f"I received {dimension=} in {listDimensions=}, but the product of the dimensions exceeds the maximum size of an integer on this system.")
 			productDimensions *= dimension
 
 		return productDimensions
 
-def getPathFilenameFoldsTotal(mapShape: Union[Sequence[int], ndarray[Tuple[int], dtype[integer[Any]]]], pathLikeWriteFoldsTotal: Optional[Union[str, os.PathLike[str]]] = None) -> pathlib.Path:
+def getPathFilenameFoldsTotal(mapShape: Sequence[int] | ndarray[tuple[int], dtype[integer[Any]]], 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
@@ -86,7 +87,7 @@ def getPathFilenameFoldsTotal(mapShape: Union[Sequence[int], ndarray[Tuple[int],
 	Returns:
 		pathFilenameFoldsTotal: Absolute path and filename.
 	"""
-	pathLikeSherpa = pathlib.Path(pathLikeWriteFoldsTotal) if pathLikeWriteFoldsTotal is not None else None
+	pathLikeSherpa = Path(pathLikeWriteFoldsTotal) if pathLikeWriteFoldsTotal is not None else None
 	if not pathLikeSherpa:
 		pathLikeSherpa = getPathJobRootDEFAULT()
 	if pathLikeSherpa.is_dir():
@@ -99,7 +100,7 @@ def getPathFilenameFoldsTotal(mapShape: Union[Sequence[int], ndarray[Tuple[int],
 	pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
 	return pathFilenameFoldsTotal
 
-def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrencyLimit: int, CPUlimit: Optional[Union[bool, float, int]], listDimensions: Sequence[int]) -> int:
+def getTaskDivisions(computationDivisions: int | str | None, concurrencyLimit: int, CPUlimit: bool | float | int | None, listDimensions: Sequence[int]) -> int:
 	"""
 	Determines whether to divide the computation into tasks and how many divisions.
 
@@ -152,7 +153,7 @@ def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrenc
 
 	return taskDivisions
 
-def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optional[str]) -> ndarray[Tuple[int, int, int], dtype[integer[Any]]]:
+def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: str | None) -> ndarray[tuple[int, int, int], dtype[integer[Any]]]:
 	"""
 	Constructs a multi-dimensional connection graph representing the connections between the leaves of a map with the given dimensions.
 	Also called a Cartesian product decomposition or dimensional product mapping.
@@ -179,7 +180,7 @@ def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optio
 		for leaf1ndex in range(1, leavesTotal + 1):
 			coordinateSystem[indexDimension, leaf1ndex] = ( ((leaf1ndex - 1) // cumulativeProduct[indexDimension]) % arrayDimensions[indexDimension] + 1 )
 
-	connectionGraph = numpy.zeros((dimensionsTotal, leavesTotal + 1, leavesTotal + 1), dtype=dtype)
+	connectionGraph: ndarray[tuple[int, int, int], numpy.dtype[integer[Any]]] = numpy.zeros((dimensionsTotal, leavesTotal + 1, leavesTotal + 1), dtype=dtype)
 	for indexDimension in range(dimensionsTotal):
 		for activeLeaf1ndex in range(1, leavesTotal + 1):
 			for connectee1ndex in range(1, activeLeaf1ndex + 1):
@@ -197,7 +198,7 @@ def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optio
 
 	return connectionGraph
 
-def makeDataContainer(shape: Union[int, Tuple[int, ...]], datatype: Optional[DTypeLike] = None) -> NDArray[integer[Any]]:
+def makeDataContainer(shape: int | tuple[int, ...], datatype: DTypeLike | None = None) -> NDArray[integer[Any]]:
 	"""Create a zeroed-out `ndarray` with the given shape and datatype.
 
 	Parameters:
@@ -219,7 +220,7 @@ def makeDataContainer(shape: Union[int, Tuple[int, ...]], datatype: Optional[DTy
 	else:
 		raise NotImplementedError("Somebody done broke it.")
 
-def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, **keywordArguments: Optional[Union[str, bool]]) -> computationState:
+def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: int | str | None = None, CPUlimit: bool | float | int | None = None, **keywordArguments: str | bool | None) -> computationState:
 	"""
 	Initializes and configures the computation state for map folding computations.
 
@@ -284,7 +285,7 @@ def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: Option
 
 	return stateInitialized
 
-def parseDimensions(dimensions: Sequence[int], parameterName: str = 'listDimensions') -> List[int]:
+def parseDimensions(dimensions: Sequence[int], parameterName: str = 'listDimensions') -> list[int]:
 	"""
 	Parse and validate the dimensions are non-negative integers.
 
@@ -306,7 +307,7 @@ def parseDimensions(dimensions: Sequence[int], parameterName: str = 'listDimensi
 
 	return listNonNegative
 
-def saveFoldsTotal(pathFilename: Union[str, os.PathLike[str]], foldsTotal: int) -> None:
+def saveFoldsTotal(pathFilename: str | os.PathLike[str], foldsTotal: int) -> None:
 	"""
 	Save foldsTotal with multiple fallback mechanisms.
 
@@ -315,7 +316,7 @@ def saveFoldsTotal(pathFilename: Union[str, os.PathLike[str]], foldsTotal: int)
 		foldsTotal: Critical computed value to save
 	"""
 	try:
-		pathFilenameFoldsTotal = pathlib.Path(pathFilename)
+		pathFilenameFoldsTotal = Path(pathFilename)
 		pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
 		pathFilenameFoldsTotal.write_text(str(foldsTotal))
 	except Exception as ERRORmessage:
@@ -333,7 +334,7 @@ def saveFoldsTotal(pathFilename: Union[str, os.PathLike[str]], foldsTotal: int)
 		except Exception:
 			print(foldsTotal)
 
-def setCPUlimit(CPUlimit: Optional[Any]) -> int:
+def setCPUlimit(CPUlimit: Any | None) -> int:
 	"""Sets CPU limit for Numba concurrent operations. Note that it can only affect Numba-jitted functions that have not yet been imported.
 
 	Parameters:
@@ -355,12 +356,12 @@ def setCPUlimit(CPUlimit: Optional[Any]) -> int:
 		CPUlimit = oopsieKwargsie(CPUlimit)
 
 	concurrencyLimit = int(defineConcurrencyLimit(CPUlimit))
-	numba.set_num_threads(concurrencyLimit)
-	concurrencyLimit = numba.get_num_threads()
+	set_num_threads(concurrencyLimit)
+	concurrencyLimit = get_num_threads()
 
 	return concurrencyLimit
 
-def validateListDimensions(listDimensions: Sequence[int]) -> List[int]:
+def validateListDimensions(listDimensions: Sequence[int]) -> list[int]:
 	"""
 	Validates and sorts a sequence of at least two positive dimensions.
 

mapFolding/oeis.py

@@ -1,8 +1,8 @@
-"""Everything implementing the The Online Encyclopedia of Integer Sequences (OEIS);
-_only_ things that implement _only_ the OEIS."""
+"""Everything implementing the The Online Encyclopedia of Integer Sequences (OEIS); _only_ things that implement _only_ the OEIS."""
+from collections.abc import Callable
 from datetime import datetime, timedelta
 from mapFolding import countFolds, getPathPackage
-from typing import Any, Callable, Dict, Final, List, Tuple, TYPE_CHECKING
+from typing import Any, Final, TYPE_CHECKING
 import argparse
 import pathlib
 import random
@@ -17,6 +17,8 @@ if TYPE_CHECKING:
 else:
 	TypedDict = dict
 
+cacheDays = 7
+
 """
 Section: make `settingsOEIS`"""
 
@@ -24,15 +26,15 @@ _pathCache = getPathPackage() / ".cache"
 
 class SettingsOEIS(TypedDict):
 	description: str
-	getMapShape: Callable[[int], List[int]]
+	getMapShape: Callable[[int], list[int]]
 	offset: int
-	valuesBenchmark: List[int]
-	valuesKnown: Dict[int, int]
-	valuesTestParallelization: List[int]
-	valuesTestValidation: List[int]
+	valuesBenchmark: list[int]
+	valuesKnown: dict[int, int]
+	valuesTestParallelization: list[int]
+	valuesTestValidation: list[int]
 	valueUnknown: int
 
-settingsOEIShardcodedValues: Dict[str, Dict[str, Any]] = {
+settingsOEIShardcodedValues: dict[str, dict[str, Any]] = {
 	'A001415': {
 		'getMapShape': lambda n: sorted([2, n]),
 		'valuesBenchmark': [14],
@@ -65,7 +67,7 @@ settingsOEIShardcodedValues: Dict[str, Dict[str, Any]] = {
 	},
 }
 
-oeisIDsImplemented: Final[List[str]]  = sorted([oeisID.upper().strip() for oeisID in settingsOEIShardcodedValues.keys()])
+oeisIDsImplemented: Final[list[str]]  = sorted([oeisID.upper().strip() for oeisID in settingsOEIShardcodedValues.keys()])
 """Directly implemented OEIS IDs; standardized, e.g., 'A001415'."""
 
 def validateOEISid(oeisIDcandidate: str) -> str:
@@ -102,7 +104,7 @@ def getFilenameOEISbFile(oeisID: str) -> str:
 	oeisID = validateOEISid(oeisID)
 	return f"b{oeisID[1:]}.txt"
 
-def _parseBFileOEIS(OEISbFile: str, oeisID: str) -> Dict[int, int]:
+def _parseBFileOEIS(OEISbFile: str, oeisID: str) -> dict[int, int]:
 	"""
 	Parses the content of an OEIS b-file for a given sequence ID.
 
@@ -135,7 +137,6 @@ def _parseBFileOEIS(OEISbFile: str, oeisID: str) -> Dict[int, int]:
 	return OEISsequence
 
 def getOEISofficial(pathFilenameCache: pathlib.Path, url: str) -> None | str:
-	cacheDays = 7
 	tryCache = False
 	if pathFilenameCache.exists():
 		fileAge = datetime.now() - datetime.fromtimestamp(pathFilenameCache.stat().st_mtime)
@@ -145,7 +146,7 @@ def getOEISofficial(pathFilenameCache: pathlib.Path, url: str) -> None | str:
 	if tryCache:
 		try:
 			oeisInformation = pathFilenameCache.read_text()
-		except IOError:
+		except OSError:
 			tryCache = False
 
 	if not tryCache:
@@ -159,7 +160,7 @@ def getOEISofficial(pathFilenameCache: pathlib.Path, url: str) -> None | str:
 
 	return oeisInformation
 
-def getOEISidValues(oeisID: str) -> Dict[int, int]:
+def getOEISidValues(oeisID: str) -> dict[int, int]:
 	"""
 	Retrieves the specified OEIS sequence as a dictionary mapping integer indices
 	to their corresponding values.
@@ -187,7 +188,7 @@ def getOEISidValues(oeisID: str) -> Dict[int, int]:
 		return _parseBFileOEIS(oeisInformation, oeisID)
 	return {-1: -1}
 
-def getOEISidInformation(oeisID: str) -> Tuple[str, int]:
+def getOEISidInformation(oeisID: str) -> tuple[str, int]:
 	oeisID = validateOEISid(oeisID)
 	pathFilenameCache = _pathCache / f"{oeisID}.txt"
 	url = f"https://oeis.org/search?q=id:{oeisID}&fmt=text"
@@ -219,7 +220,7 @@ def getOEISidInformation(oeisID: str) -> Tuple[str, int]:
 	description = ' '.join(description_parts)
 	return description, offset
 
-def makeSettingsOEIS() -> Dict[str, SettingsOEIS]:
+def makeSettingsOEIS() -> dict[str, SettingsOEIS]:
 	settingsTarget = {}
 	for oeisID in oeisIDsImplemented:
 		valuesKnownSherpa = getOEISidValues(oeisID)
@@ -236,7 +237,7 @@ def makeSettingsOEIS() -> Dict[str, SettingsOEIS]:
 		)
 	return settingsTarget
 
-settingsOEIS: Dict[str, SettingsOEIS] = makeSettingsOEIS()
+settingsOEIS: dict[str, SettingsOEIS] = makeSettingsOEIS()
 """All values and settings for `oeisIDsImplemented`."""
 
 """
@@ -288,7 +289,7 @@ def oeisIDfor_n(oeisID: str, n: int) -> int:
 	if not isinstance(n, int) or n < 0:
 		raise ValueError("`n` must be non-negative integer.")
 
-	listDimensions = settingsOEIS[oeisID]['getMapShape'](n)
+	listDimensions: list[int] = settingsOEIS[oeisID]['getMapShape'](n)
 
 	if n <= 1 or len(listDimensions) < 2:
 		offset = settingsOEIS[oeisID]['offset']
@@ -309,9 +310,9 @@ def OEIS_for_n() -> None:
 	parserCLI.add_argument('oeisID', help="OEIS sequence identifier")
 	parserCLI.add_argument('n', type=int, help="Calculate a(n) for this n")
 
-	argumentsCLI = parserCLI.parse_args()
+	argumentsCLI: argparse.Namespace = parserCLI.parse_args()
 
-	timeStart = time.perf_counter()
+	timeStart: float = time.perf_counter()
 
 	try:
 		print(oeisIDfor_n(argumentsCLI.oeisID, argumentsCLI.n), "distinct folding patterns.")

mapFolding/someAssemblyRequired/makeJob.py

@@ -1,14 +1,15 @@
+from collections.abc import Sequence
 from mapFolding import getPathFilenameFoldsTotal, computationState, outfitCountFolds, getAlgorithmSource
+from pathlib import Path
 from types import ModuleType
-from typing import Any, Literal, Optional, Sequence, overload
-import pathlib
+from typing import Any, Literal, overload
 import pickle
 
 @overload
-def makeStateJob(listDimensions: Sequence[int], *, writeJob: Literal[True] , **keywordArguments: Optional[str]) -> pathlib.Path: ...
+def makeStateJob(listDimensions: Sequence[int], *, writeJob: Literal[True] , **keywordArguments: str | None) -> Path: ...
 @overload
-def makeStateJob(listDimensions: Sequence[int], *, writeJob: Literal[False] , **keywordArguments: Optional[str]) -> computationState: ...
-def makeStateJob(listDimensions: Sequence[int], *, writeJob: bool = True, **keywordArguments: Optional[Any]) -> computationState | pathlib.Path:
+def makeStateJob(listDimensions: Sequence[int], *, writeJob: Literal[False] , **keywordArguments: str | None) -> computationState: ...
+def makeStateJob(listDimensions: Sequence[int], *, writeJob: bool = True, **keywordArguments: Any | None) -> computationState | Path:
 	"""
 	Creates a computation state job for map folding calculations and optionally saves it to disk.
 
@@ -27,7 +28,7 @@ def makeStateJob(listDimensions: Sequence[int], *, writeJob: bool = True, **keyw
 
 	Returns
 	-------
-	Union[computationState, pathlib.Path]
+	Union[computationState, Path]
 		If writeJob is False, returns the computation state object.
 		If writeJob is True, returns the Path object pointing to the saved state file.
 
@@ -47,7 +48,7 @@ def makeStateJob(listDimensions: Sequence[int], *, writeJob: bool = True, **keyw
 
 	pathFilenameChopChop = getPathFilenameFoldsTotal(stateUniversal['mapShape'])
 	suffix = pathFilenameChopChop.suffix
-	pathJob = pathlib.Path(str(pathFilenameChopChop)[0:-len(suffix)])
+	pathJob = Path(str(pathFilenameChopChop)[0:-len(suffix)])
 	pathJob.mkdir(parents=True, exist_ok=True)
 	pathFilenameJob = pathJob / 'stateJob.pkl'
 

mapFolding/someAssemblyRequired/synthesizeModuleJAX.py

@@ -1,15 +1,13 @@
 from mapFolding import getAlgorithmSource, getPathSyntheticModules
 from mapFolding import setDatatypeModule, setDatatypeFoldsTotal, setDatatypeElephino, setDatatypeLeavesTotal
-from typing import Optional
 import ast
 import inspect
 import pathlib
-import sys
 
 def transformPythonToJAX(codePython: str) -> None:
 	astPython = ast.parse(codePython)
 
-def writeJax(*, codeSource: Optional[str] = None, pathFilenameAlgorithm: Optional[pathlib.Path] = None, pathFilenameDestination: Optional[pathlib.Path] = None) -> None:
+def writeJax(*, codeSource: str | None = None, pathFilenameAlgorithm: pathlib.Path | None = None, pathFilenameDestination: pathlib.Path | None = None) -> None:
 	if codeSource is None and pathFilenameAlgorithm is None:
 		algorithmSource = getAlgorithmSource()
 		codeSource = inspect.getsource(algorithmSource)

mapFolding/someAssemblyRequired/synthesizeNumba.py

@@ -2,7 +2,7 @@
 TODO: consolidate the logic in this module."""
 from mapFolding.someAssemblyRequired.synthesizeNumbaGeneralized import *
 
-def insertArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arrayTarget: numpy.ndarray, allImports: UniversalImportTracker, unrollSlices: Optional[int]=None) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+def insertArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arrayTarget: numpy.ndarray, allImports: UniversalImportTracker, unrollSlices: int | None = None) -> tuple[ast.FunctionDef, UniversalImportTracker]:
 	arrayType = type(arrayTarget)
 	moduleConstructor = arrayType.__module__
 	constructorName = arrayType.__name__
@@ -34,7 +34,7 @@ def insertArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arra
 
 	return FunctionDefTarget, allImports
 
-def findAndReplaceTrackArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str , arrayTarget: numpy.ndarray , allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+def findAndReplaceTrackArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str , arrayTarget: numpy.ndarray , allImports: UniversalImportTracker) -> tuple[ast.FunctionDef, UniversalImportTracker]:
 
 	arrayType = type(arrayTarget)
 	moduleConstructor = arrayType.__module__
@@ -62,7 +62,7 @@ def findAndReplaceTrackArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifi
 			allImports.addImportFromStr(moduleConstructor, datatypeName, dtypeAsName)
 	return FunctionDefTarget, allImports
 
-def findAndReplaceArraySubscriptIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arrayTarget: numpy.ndarray, Z0Z_listChaff: List[str], allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+def findAndReplaceArraySubscriptIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arrayTarget: numpy.ndarray, Z0Z_listChaff: list[str], allImports: UniversalImportTracker) -> tuple[ast.FunctionDef, UniversalImportTracker]:
 	moduleConstructor = Z0Z_getDatatypeModuleScalar()
 	for statement in FunctionDefTarget.body.copy():
 		if ifThis.isUnpackingAnArray(identifier)(statement):
@@ -87,7 +87,7 @@ def removeAssignTargetFrom_body(FunctionDefTarget: ast.FunctionDef, identifier:
 			return False
 		targetNode = astNode.targets[0]
 		return (isinstance(targetNode, ast.Subscript) and isinstance(targetNode.value, ast.Name) and targetNode.value.id == identifier) or ifThis.nameIs(identifier)(targetNode)
-	def replacementBuilder(astNode: ast.AST) -> Optional[ast.stmt]:
+	def replacementBuilder(astNode: ast.AST) -> ast.stmt | None:
 		# Returning None removes the node.
 		return None
 	FunctionDefSherpa = NodeReplacer(predicate, replacementBuilder).visit(FunctionDefTarget)
@@ -98,7 +98,7 @@ def removeAssignTargetFrom_body(FunctionDefTarget: ast.FunctionDef, identifier:
 	ast.fix_missing_locations(FunctionDefTarget)
 	return FunctionDefTarget
 
-def findAndReplaceAnnAssignIn_body(FunctionDefTarget: ast.FunctionDef, allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+def findAndReplaceAnnAssignIn_body(FunctionDefTarget: ast.FunctionDef, allImports: UniversalImportTracker) -> tuple[ast.FunctionDef, UniversalImportTracker]:
 	moduleConstructor = Z0Z_getDatatypeModuleScalar()
 	for stmt in FunctionDefTarget.body.copy():
 		if isinstance(stmt, ast.AnnAssign):
@@ -137,7 +137,7 @@ def findAstNameReplaceWithConstantIn_body(FunctionDefTarget: ast.FunctionDef, na
 
 	return cast(ast.FunctionDef, NodeReplacer(ifThis.nameIs(name), replaceWithConstant).visit(FunctionDefTarget))
 
-def insertReturnStatementIn_body(FunctionDefTarget: ast.FunctionDef, arrayTarget: numpy.ndarray, allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+def insertReturnStatementIn_body(FunctionDefTarget: ast.FunctionDef, arrayTarget: numpy.ndarray, allImports: UniversalImportTracker) -> tuple[ast.FunctionDef, UniversalImportTracker]:
 	"""Add multiplication and return statement to function, properly constructing AST nodes."""
 	# Create AST for multiplication operation
 	multiplicand = Z0Z_identifierCountFolds
@@ -157,7 +157,7 @@ def insertReturnStatementIn_body(FunctionDefTarget: ast.FunctionDef, arrayTarget
 
 	return FunctionDefTarget, allImports
 
-def findAndReplaceWhileLoopIn_body(FunctionDefTarget: ast.FunctionDef, iteratorName: str, iterationsTotal: int) -> Any:
+def findAndReplaceWhileLoopIn_body(FunctionDefTarget: ast.FunctionDef, iteratorName: str, iterationsTotal: int) -> ast.FunctionDef:
 	"""
 	Unroll all nested while loops matching the condition that their test uses `iteratorName`.
 	"""
@@ -180,11 +180,11 @@ def findAndReplaceWhileLoopIn_body(FunctionDefTarget: ast.FunctionDef, iteratorN
 			self.iteratorName = iteratorName
 			self.iterationsTotal = iterationsTotal
 
-		def visit_While(self, node: ast.While) -> List[ast.stmt]:
+		def visit_While(self, node: ast.While) -> list[ast.stmt]:
 				# Check if the while loop's test uses the iterator.
 			if isinstance(node.test, ast.Compare) and ifThis.nameIs(self.iteratorName)(node.test.left):
 				# Recurse the while loop body and remove AugAssign that increments the iterator.
-				cleanBodyStatements: List[ast.stmt] = []
+				cleanBodyStatements: list[ast.stmt] = []
 				for loopStatement in node.body:
 					# Recursively visit nested statements.
 					visitedStatement = self.visit(loopStatement)
@@ -198,7 +198,7 @@ def findAndReplaceWhileLoopIn_body(FunctionDefTarget: ast.FunctionDef, iteratorN
 						continue
 					cleanBodyStatements.append(visitedStatement)
 
-				newStatements: List[ast.stmt] = []
+				newStatements: list[ast.stmt] = []
 				# Unroll using the filtered body.
 				for iterationIndex in range(self.iterationsTotal):
 					for loopStatement in cleanBodyStatements:
@@ -222,7 +222,7 @@ def findAndReplaceWhileLoopIn_body(FunctionDefTarget: ast.FunctionDef, iteratorN
 	ast.fix_missing_locations(newFunctionDef)
 	return newFunctionDef
 
-def makeLauncherBasicJobNumba(callableTarget: str, pathFilenameFoldsTotal: pathlib.Path) -> ast.Module:
+def makeLauncherBasicJobNumba(callableTarget: str, pathFilenameFoldsTotal: Path) -> ast.Module:
 	linesLaunch = f"""
 if __name__ == '__main__':
 	import time
@@ -235,7 +235,12 @@ if __name__ == '__main__':
 """
 	return ast.parse(linesLaunch)
 
-def makeFunctionDef(astModule: ast.Module, callableTarget: str, parametersNumba: Optional[ParametersNumba]=None, inlineCallables: Optional[bool]=False, unpackArrays: Optional[bool]=False, allImports: Optional[UniversalImportTracker]=None) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+def makeFunctionDef(astModule: ast.Module,
+					callableTarget: str,
+					parametersNumba: ParametersNumba | None = None,
+					inlineCallables: bool | None = False,
+					unpackArrays: bool | None = False,
+					allImports: UniversalImportTracker | None = None) -> tuple[ast.FunctionDef, UniversalImportTracker]:
 	if allImports is None:
 		allImports = UniversalImportTracker()
 	for statement in astModule.body:
@@ -266,7 +271,7 @@ def makeFunctionDef(astModule: ast.Module, callableTarget: str, parametersNumba:
 
 	return FunctionDefTarget, allImports
 
-def decorateCallableWithNumba(FunctionDefTarget: ast.FunctionDef, allImports: UniversalImportTracker, parametersNumba: Optional[ParametersNumba]=None) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+def decorateCallableWithNumba(FunctionDefTarget: ast.FunctionDef, allImports: UniversalImportTracker, parametersNumba: ParametersNumba | None = None) -> tuple[ast.FunctionDef, UniversalImportTracker]:
 	def Z0Z_UnhandledDecorators(astCallable: ast.FunctionDef) -> ast.FunctionDef:
 		# TODO: more explicit handling of decorators. I'm able to ignore this because I know `algorithmSource` doesn't have any decorators.
 		for decoratorItem in astCallable.decorator_list.copy():
@@ -303,7 +308,7 @@ def decorateCallableWithNumba(FunctionDefTarget: ast.FunctionDef, allImports: Un
 	datatypeModuleDecorator = Z0Z_getDatatypeModuleScalar()
 	list_argsDecorator: Sequence[ast.expr] = []
 
-	list_arg4signature_or_function: List[ast.expr] = []
+	list_arg4signature_or_function: list[ast.expr] = []
 	for parameter in FunctionDefTarget.args.args:
 		signatureElement = make_arg4parameter(parameter)
 		if signatureElement:

mapFolding/someAssemblyRequired/synthesizeNumbaGeneralized.py

@@ -35,7 +35,8 @@ from mapFolding.someAssemblyRequired.makeJob import makeStateJob
 from numpy import integer
 from numpy.typing import NDArray
 from types import ModuleType
-from typing import Any, Callable, cast, Dict, List, Optional, Sequence, Set, Tuple, Type, Union
+from collections.abc import Callable, Sequence
+from typing import Any, cast
 from Z0Z_tools import autoDecodingRLE, updateExtendPolishDictionaryLists
 import ast
 import autoflake
@@ -46,8 +47,8 @@ import inspect
 import more_itertools
 import numba
 import numpy
-import os
-import pathlib
+from os import PathLike
+from pathlib import Path
 import python_minifier
 import warnings
 
@@ -63,8 +64,8 @@ class ASTBodyTransformer:
 	def __init__(self, functionDefinition: ast.FunctionDef) -> None:
 		self.functionDefinition = functionDefinition
 
-	def replaceIn_body(self, predicate: Callable[[ast.stmt], bool], replacementBuilder: Callable[[ast.stmt], Optional[ast.stmt]]) -> None:
-		newBody: List[ast.stmt] = []
+	def replaceIn_body(self, predicate: Callable[[ast.stmt], bool], replacementBuilder: Callable[[ast.stmt], ast.stmt | None]) -> None:
+		newBody: list[ast.stmt] = []
 		for statement in self.functionDefinition.body:
 			if predicate(statement):
 				replacementStatement = replacementBuilder(statement)
@@ -127,16 +128,16 @@ class ifThis:
 class Then:
 	"""Generic actions."""
 	@staticmethod
-	def copy_astCallKeywords(astCall: ast.Call) -> Dict[str, Any]:
+	def copy_astCallKeywords(astCall: ast.Call) -> dict[str, Any]:
 		"""Extract keyword parameters from a decorator AST node."""
-		dictionaryKeywords: Dict[str, Any] = {}
+		dictionaryKeywords: dict[str, Any] = {}
 		for keywordItem in astCall.keywords:
 			if isinstance(keywordItem.value, ast.Constant) and keywordItem.arg is not None:
 				dictionaryKeywords[keywordItem.arg] = keywordItem.value.value
 		return dictionaryKeywords
 
 	@staticmethod
-	def make_astCall(name: str, args: Optional[Sequence[ast.expr]]=None, list_astKeywords: Optional[Sequence[ast.keyword]]=None, dictionaryKeywords: Optional[Dict[str, Any]]=None) -> ast.Call:
+	def make_astCall(name: str, args: Sequence[ast.expr] | None = None, list_astKeywords: Sequence[ast.keyword] | None = None, dictionaryKeywords: dict[str, Any] | None = None) -> ast.Call:
 		list_dictionaryKeywords = [ast.keyword(arg=keyName, value=ast.Constant(value=keyValue)) for keyName, keyValue in dictionaryKeywords.items()] if dictionaryKeywords else []
 		return ast.Call(
 			func=ast.Name(id=name, ctx=ast.Load()),
@@ -159,7 +160,7 @@ class NodeReplacer(ast.NodeTransformer):
 		visit(node: ast.AST) -> Optional[ast.AST]:
 			Visits each node in the AST, replacing or removing it based on the predicate.
 	"""
-	def __init__(self, findMe: Callable[[ast.AST], bool], nodeReplacementBuilder: Callable[[ast.AST], Optional[ast.AST]]) -> None:
+	def __init__(self, findMe: Callable[[ast.AST], bool], nodeReplacementBuilder: Callable[[ast.AST], ast.AST | None]) -> None:
 		self.findMe = findMe
 		self.nodeReplacementBuilder = nodeReplacementBuilder
 
@@ -181,10 +182,10 @@ def thisIsAnyNumbaJitDecorator(Ima: ast.AST) -> bool:
 # Domain-based
 class UniversalImportTracker:
 	def __init__(self) -> None:
-		self.dictionaryImportFrom: Dict[str, Set] = collections.defaultdict(set)
+		self.dictionaryImportFrom: dict[str, set] = collections.defaultdict(set)
 		self.setImport = set()
 
-	def addAst(self, astImport_: Union[ast.Import, ast.ImportFrom]) -> None:
+	def addAst(self, astImport_: ast.Import | ast.ImportFrom) -> None:
 		if isinstance(astImport_, ast.Import):
 			for alias in astImport_.names:
 				self.setImport.add(alias.name)
@@ -195,10 +196,10 @@ class UniversalImportTracker:
 	def addImportStr(self, module: str) -> None:
 		self.setImport.add(module)
 
-	def addImportFromStr(self, module: str, name: str, asname: Optional[str] = None) -> None:
+	def addImportFromStr(self, module: str, name: str, asname: str | None = None) -> None:
 		self.dictionaryImportFrom[module].add((name, asname))
 
-	def makeListAst(self) -> List[Union[ast.ImportFrom, ast.Import]]:
+	def makeListAst(self) -> list[ast.ImportFrom | ast.Import]:
 		listAstImportFrom = []
 		for module, setOfNameTuples in sorted(self.dictionaryImportFrom.items()):
 			listAliases = []
@@ -253,11 +254,11 @@ class RecursiveInliner(ast.NodeTransformer):
 				dictionaryFunctions, its statements are expanded in place, effectively inlining
 				the called function's statements into the surrounding context.
 	"""
-	def __init__(self, dictionaryFunctions: Dict[str, ast.FunctionDef]):
+	def __init__(self, dictionaryFunctions: dict[str, ast.FunctionDef]):
 		self.dictionaryFunctions = dictionaryFunctions
-		self.callablesCompleted: Set[str] = set()
+		self.callablesCompleted: set[str] = set()
 
-	def inlineFunctionBody(self, callableTargetName: str) -> Optional[ast.FunctionDef]:
+	def inlineFunctionBody(self, callableTargetName: str) -> ast.FunctionDef | None:
 		if (callableTargetName in self.callablesCompleted):
 			return None
 
@@ -280,7 +281,7 @@ class RecursiveInliner(ast.NodeTransformer):
 				return ast.Constant(value=None)
 		return callNodeVisited
 
-	def visit_Expr(self, node: ast.Expr) -> Union[ast.AST, List[ast.AST]]:
+	def visit_Expr(self, node: ast.Expr) -> ast.AST | list[ast.AST]:
 		if (isinstance(node.value, ast.Call)):
 			if (isinstance(node.value.func, ast.Name) and node.value.func.id in self.dictionaryFunctions):
 				inlineDefinition = self.inlineFunctionBody(node.value.func.id)
@@ -313,12 +314,12 @@ class UnpackArrays(ast.NodeTransformer):
 	3. Replaces original array access with the local variable
 	"""
 
-	def __init__(self, enumIndexClass: Type[EnumIndices], arrayName: str) -> None:
+	def __init__(self, enumIndexClass: type[EnumIndices], arrayName: str) -> None:
 		self.enumIndexClass = enumIndexClass
 		self.arrayName = arrayName
-		self.substitutions: Dict[str, Any] = {}
+		self.substitutions: dict[str, Any] = {}
 
-	def extract_member_name(self, node: ast.AST) -> Optional[str]:
+	def extract_member_name(self, node: ast.AST) -> str | None:
 		"""Recursively extract enum member name from any node in the AST."""
 		if isinstance(node, ast.Attribute) and node.attr == 'value':
 			innerAttribute = node.value
@@ -337,7 +338,7 @@ class UnpackArrays(ast.NodeTransformer):
 					return ast.Name(id=member_name, ctx=node.ctx)
 			elif isinstance(node, ast.Tuple):
 				# Handle tuple slices by transforming each element
-				return ast.Tuple(elts=cast(List[ast.expr], [self.transform_slice_element(elt) for elt in node.elts]), ctx=node.ctx)
+				return ast.Tuple(elts=cast(list[ast.expr], [self.transform_slice_element(elt) for elt in node.elts]), ctx=node.ctx)
 		elif isinstance(node, ast.Attribute):
 			member_name = self.extract_member_name(node)
 			if member_name: