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

mapFolding/theDao.py

@@ -1,93 +1,93 @@
 from mapFolding import indexMy, indexTrack
 from numba import prange
 from numpy import dtype, integer, ndarray
-from typing import Any, Tuple
+from typing import Any
 
 # `.value` is not necessary for this module or most modules. But, this module is transformed into Numba "jitted" functions, and Numba won't use `Enum` for an ndarray index without `.value`.
-def activeLeafConnectedToItself(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def activeLeafConnectedToItself(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.leafConnectee.value] == my[indexMy.leaf1ndex.value]
 
-def activeLeafGreaterThan0(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def activeLeafGreaterThan0(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.leaf1ndex.value] > 0
 
-def activeLeafGreaterThanLeavesTotal(foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def activeLeafGreaterThanLeavesTotal(foldGroups: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.leaf1ndex.value] > foldGroups[-1]
 
-def activeLeafIsTheFirstLeaf(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def activeLeafIsTheFirstLeaf(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.leaf1ndex.value] <= 1
 
-def allDimensionsAreUnconstrained(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def allDimensionsAreUnconstrained(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return not my[indexMy.dimensionsUnconstrained.value]
 
-def backtrack(my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
+def backtrack(my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
 	my[indexMy.leaf1ndex.value] -= 1
 	track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]
 	track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]
 
-def countGaps(gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
+def countGaps(gapsWhere: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
 	gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.leafConnectee.value]
 	if track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] == 0:
 		incrementGap1ndexCeiling(my=my)
 	track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
 
-def decrementDimensionsUnconstrained(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def decrementDimensionsUnconstrained(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
 	my[indexMy.dimensionsUnconstrained.value] -= 1
 
-def dimensionsUnconstrainedCondition(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def dimensionsUnconstrainedCondition(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]
 
-def filterCommonGaps(gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
+def filterCommonGaps(gapsWhere: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
 	gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
 	if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsUnconstrained.value]:
 		incrementActiveGap(my=my)
 	track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
 
-def incrementActiveGap(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def incrementActiveGap(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
 	my[indexMy.gap1ndex.value] += 1
 
-def incrementGap1ndexCeiling(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def incrementGap1ndexCeiling(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
 	my[indexMy.gap1ndexCeiling.value] += 1
 
-def incrementIndexDimension(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def incrementIndexDimension(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
 	my[indexMy.indexDimension.value] += 1
 
-def incrementIndexMiniGap(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def incrementIndexMiniGap(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
 	my[indexMy.indexMiniGap.value] += 1
 
-def initializeIndexMiniGap(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def initializeIndexMiniGap(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
 	my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
 
-def initializeLeafConnectee(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def initializeLeafConnectee(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
 	my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
 
-def initializeVariablesToFindGaps(my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
+def initializeVariablesToFindGaps(my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
 	my[indexMy.dimensionsUnconstrained.value] = my[indexMy.dimensionsTotal.value]
 	my[indexMy.gap1ndexCeiling.value] = track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
 	my[indexMy.indexDimension.value] = 0
 
-def insertUnconstrainedLeaf(gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def insertUnconstrainedLeaf(gapsWhere: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
 	my[indexMy.indexLeaf.value] = 0
 	while my[indexMy.indexLeaf.value] < my[indexMy.leaf1ndex.value]:
 		gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.indexLeaf.value]
 		my[indexMy.gap1ndexCeiling.value] += 1
 		my[indexMy.indexLeaf.value] += 1
 
-def leafBelowSentinelIs1(track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> Any:
+def leafBelowSentinelIs1(track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> Any:
 	return track[indexTrack.leafBelow.value, 0] == 1
 
-def loopingLeavesConnectedToActiveLeaf(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def loopingLeavesConnectedToActiveLeaf(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]
 
-def loopingToActiveGapCeiling(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def loopingToActiveGapCeiling(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]
 
-def loopUpToDimensionsTotal(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def loopUpToDimensionsTotal(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]
 
-def noGapsHere(my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> Any:
+def noGapsHere(my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.leaf1ndex.value] > 0 and my[indexMy.gap1ndex.value] == track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
 
-def placeLeaf(gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
+def placeLeaf(gapsWhere: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
 	my[indexMy.gap1ndex.value] -= 1
 	track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]] = gapsWhere[my[indexMy.gap1ndex.value]]
 	track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]] = track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]]
@@ -96,19 +96,19 @@ def placeLeaf(gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[T
 	track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
 	my[indexMy.leaf1ndex.value] += 1
 
-def thereIsAnActiveLeaf(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def thereIsAnActiveLeaf(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.leaf1ndex.value] > 0
 
-def thisIsMyTaskIndex(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def thisIsMyTaskIndex(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.leaf1ndex.value] != my[indexMy.taskDivisions.value] or my[indexMy.leafConnectee.value] % my[indexMy.taskDivisions.value] == my[indexMy.taskIndex.value]
 
-def updateLeafConnectee(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
+def updateLeafConnectee(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> None:
 	my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
 
-def countInitialize(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]]
-						, gapsWhere: ndarray[Tuple[int]			 , dtype[integer[Any]]]
-						,		 my: ndarray[Tuple[int]			 , dtype[integer[Any]]]
-						,	  track: ndarray[Tuple[int, int]	 , dtype[integer[Any]]]
+def countInitialize(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]]
+						, gapsWhere: ndarray[tuple[int]			 , dtype[integer[Any]]]
+						,		 my: ndarray[tuple[int]			 , dtype[integer[Any]]]
+						,	  track: ndarray[tuple[int, int]	 , dtype[integer[Any]]]
 					) -> None:
 
 	while activeLeafGreaterThan0(my=my):
@@ -134,11 +134,11 @@ def countInitialize(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer
 		if my[indexMy.gap1ndex.value] > 0:
 			return
 
-def countParallel(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]]
-					,  foldGroups: ndarray[Tuple[int]		   , dtype[integer[Any]]]
-					,   gapsWhere: ndarray[Tuple[int]		   , dtype[integer[Any]]]
-					,		   my: ndarray[Tuple[int]		   , dtype[integer[Any]]]
-					,		track: ndarray[Tuple[int, int]	   , dtype[integer[Any]]]
+def countParallel(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]]
+					,  foldGroups: ndarray[tuple[int]		   , dtype[integer[Any]]]
+					,   gapsWhere: ndarray[tuple[int]		   , dtype[integer[Any]]]
+					,		   my: ndarray[tuple[int]		   , dtype[integer[Any]]]
+					,		track: ndarray[tuple[int, int]	   , dtype[integer[Any]]]
 				) -> None:
 
 	gapsWherePARALLEL = gapsWhere.copy()
@@ -182,11 +182,11 @@ def countParallel(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[A
 				placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
 		foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
 
-def countSequential( connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]]
-						, foldGroups: ndarray[Tuple[int]		  , dtype[integer[Any]]]
-						,  gapsWhere: ndarray[Tuple[int]		  , dtype[integer[Any]]]
-						,		  my: ndarray[Tuple[int]		  , dtype[integer[Any]]]
-						,	   track: ndarray[Tuple[int, int]	  , dtype[integer[Any]]]
+def countSequential( connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]]
+						, foldGroups: ndarray[tuple[int]		  , dtype[integer[Any]]]
+						,  gapsWhere: ndarray[tuple[int]		  , dtype[integer[Any]]]
+						,		  my: ndarray[tuple[int]		  , dtype[integer[Any]]]
+						,	   track: ndarray[tuple[int, int]	  , dtype[integer[Any]]]
 					) -> None:
 
 	groupsOfFolds: int = 0
@@ -216,12 +216,12 @@ def countSequential( connectionGraph: ndarray[Tuple[int, int, int], dtype[intege
 			placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
 	foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
 
-def doTheNeedful(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]]
-					, foldGroups: ndarray[Tuple[int]		  , dtype[integer[Any]]]
-					,  gapsWhere: ndarray[Tuple[int]		  , dtype[integer[Any]]]
-					,   mapShape: ndarray[Tuple[int]		  , dtype[integer[Any]]]
-					,		  my: ndarray[Tuple[int]		  , dtype[integer[Any]]]
-					,	   track: ndarray[Tuple[int, int]	  , dtype[integer[Any]]]
+def doTheNeedful(connectionGraph: ndarray[tuple[int, int, int], dtype[integer[Any]]]
+					, foldGroups: ndarray[tuple[int]		  , dtype[integer[Any]]]
+					,  gapsWhere: ndarray[tuple[int]		  , dtype[integer[Any]]]
+					,   mapShape: ndarray[tuple[int]		  , dtype[integer[Any]]]
+					,		  my: ndarray[tuple[int]		  , dtype[integer[Any]]]
+					,	   track: ndarray[tuple[int, int]	  , dtype[integer[Any]]]
 					) -> None:
 
 	countInitialize(connectionGraph, gapsWhere, my, track)

mapFolding/theSSOT.py

@@ -1,15 +1,16 @@
+from collections.abc import Callable
 from mapFolding.theSSOTdatatypes import *
 from numba.core.compiler import CompilerBase as numbaCompilerBase
 from numpy import dtype, integer, ndarray
+from pathlib import Path
+from sys import modules as sysModules
 from types import ModuleType
-from typing import Any, Callable, Dict, Final, Tuple, TYPE_CHECKING, Union, cast
-import pathlib
-import sys
+from typing import Any, Final, TYPE_CHECKING, cast
 
 try:
 	from typing import NotRequired
-except ImportError:
-	from typing_extensions import NotRequired
+except Exception:
+	from typing_extensions import NotRequired # type: ignore
 
 if TYPE_CHECKING:
 	from typing import TypedDict
@@ -31,23 +32,24 @@ myPackageNameIs = "mapFolding"
 moduleOfSyntheticModules = "syntheticModules"
 # TODO I'm not sure if this is the right tool for the job.
 formatFilenameModuleDEFAULT = "numba_{callableTarget}.py"
+# TODO figure out how to implement this
 dispatcherCallableNameDEFAULT = "doTheNeedful"
 
-def getPathPackage() -> pathlib.Path:
+def getPathPackage() -> Path:
 	import importlib, inspect
-	pathPackage = pathlib.Path(inspect.getfile(importlib.import_module(myPackageNameIs)))
+	pathPackage = Path(inspect.getfile(importlib.import_module(myPackageNameIs)))
 	if pathPackage.is_file():
 		pathPackage = pathPackage.parent
 	return pathPackage
 
-def getPathJobRootDEFAULT() -> pathlib.Path:
-	if 'google.colab' in sys.modules:
-		pathJobDEFAULT = pathlib.Path("/content/drive/MyDrive") / "jobs"
+def getPathJobRootDEFAULT() -> Path:
+	if 'google.colab' in sysModules:
+		pathJobDEFAULT = Path("/content/drive/MyDrive") / "jobs"
 	else:
 		pathJobDEFAULT = getPathPackage() / "jobs"
 	return pathJobDEFAULT
 
-def getPathSyntheticModules() -> pathlib.Path:
+def getPathSyntheticModules() -> Path:
 	pathSyntheticModules = getPathPackage() / moduleOfSyntheticModules
 	return pathSyntheticModules
 
@@ -65,12 +67,12 @@ def getDispatcherCallable() -> Callable[..., None]:
 
 # NOTE I want this _concept_, not necessarily this method, to be well implemented and usable everywhere: Python, Numba, Jax, CUDA, idc
 class computationState(TypedDict):
-	connectionGraph:	ndarray[Tuple[int, int, int], dtype[integer[Any]]]
-	foldGroups:			ndarray[Tuple[int]			, dtype[integer[Any]]]
-	gapsWhere:			ndarray[Tuple[int]			, dtype[integer[Any]]]
-	mapShape:			ndarray[Tuple[int]			, dtype[integer[Any]]]
-	my:					ndarray[Tuple[int]			, dtype[integer[Any]]]
-	track:				ndarray[Tuple[int, int]		, dtype[integer[Any]]]
+	connectionGraph:	ndarray[tuple[int, int, int], dtype[integer[Any]]]
+	foldGroups:			ndarray[tuple[int]			, dtype[integer[Any]]]
+	gapsWhere:			ndarray[tuple[int]			, dtype[integer[Any]]]
+	mapShape:			ndarray[tuple[int]			, dtype[integer[Any]]]
+	my:					ndarray[tuple[int]			, dtype[integer[Any]]]
+	track:				ndarray[tuple[int, int]		, dtype[integer[Any]]]
 
 _datatypeModuleScalar = 'numba'
 _decoratorCallable = 'jit'
@@ -110,7 +112,7 @@ class ParametersNumba(TypedDict):
 	forceinline: bool
 	forceobj: NotRequired[bool]
 	inline: str
-	locals: NotRequired[Dict[str, Any]]
+	locals: NotRequired[dict[str, Any]]
 	looplift: bool
 	no_cfunc_wrapper: bool
 	no_cpython_wrapper: bool
@@ -118,8 +120,8 @@ class ParametersNumba(TypedDict):
 	nogil: NotRequired[bool]
 	nopython: bool
 	parallel: bool
-	pipeline_class: NotRequired[Type[numbaCompilerBase]]
-	signature_or_function: NotRequired[Union[Any, Callable, str, Tuple]]
+	pipeline_class: NotRequired[type[numbaCompilerBase]]
+	signature_or_function: NotRequired[Any | Callable[..., Any] | str | tuple[Any, ...]]
 	target: NotRequired[str]
 
 parametersNumbaFailEarly: Final[ParametersNumba] = { '_nrt': True, 'boundscheck': True, 'cache': True, 'error_model': 'python', 'fastmath': False, 'forceinline': True, 'inline': 'always', 'looplift': False, 'no_cfunc_wrapper': False, 'no_cpython_wrapper': False, 'nopython': True, 'parallel': False, }

mapFolding/theSSOTdatatypes.py

@@ -1,21 +1,9 @@
 from collections import defaultdict
-from typing import Any, cast, Dict, Final, Optional, Type, TYPE_CHECKING
+from typing import Any, cast, Final
 import enum
-import sys
-import numba
-import numpy
+import numba # type: ignore
+import numpy # type: ignore
 
-try:
-	from typing import NotRequired
-except ImportError:
-	from typing_extensions import NotRequired
-
-if TYPE_CHECKING:
-	from typing import TypedDict
-else:
-	TypedDict = dict
-
-@enum.verify(enum.CONTINUOUS, enum.UNIQUE) if sys.version_info >= (3, 11) else lambda x: x
 class EnumIndices(enum.IntEnum):
 	@staticmethod
 	def _generate_next_value_(name: str, start: int, count: int, last_values: list[Any]) -> int:
@@ -48,17 +36,17 @@ class indexTrack(EnumIndices):
 	countDimensionsGapped	= enum.auto()
 	gapRangeStart			= enum.auto()
 
-_datatypeDefault: Final[Dict[str, str]] = {
+_datatypeDefault: Final[dict[str, str]] = {
 	'elephino': 'uint16',
 	'foldsTotal': 'int64',
 	'leavesTotal': 'uint16',
 }
-_datatypeModule = ''
+_datatypeModule: str = ''
 _datatypeModuleDEFAULT: Final[str] = 'numpy'
 
-_datatype: Dict[str, str] = defaultdict(str)
+_datatype: dict[str, str] = defaultdict(str)
 
-def reportDatatypeLimit(identifier: str, datatype: str, sourGrapes: Optional[bool] = False) -> str:
+def reportDatatypeLimit(identifier: str, datatype: str, sourGrapes: bool | None = False) -> str:
 	global _datatype
 	if not _datatype[identifier]:
 		_datatype[identifier] = datatype
@@ -68,7 +56,7 @@ def reportDatatypeLimit(identifier: str, datatype: str, sourGrapes: Optional[boo
 		raise Exception(f"Datatype is '{_datatype[identifier]}' not '{datatype}', so you can take your ball and go home.")
 	return _datatype[identifier]
 
-def setDatatypeModule(datatypeModule: str, sourGrapes: Optional[bool] = False) -> str:
+def setDatatypeModule(datatypeModule: str, sourGrapes: bool | None = False) -> str:
 	global _datatypeModule
 	if not _datatypeModule:
 		_datatypeModule = datatypeModule
@@ -78,13 +66,13 @@ def setDatatypeModule(datatypeModule: str, sourGrapes: Optional[bool] = False) -
 		raise Exception(f"Datatype module is '{_datatypeModule}' not '{datatypeModule}', so you can take your ball and go home.")
 	return _datatypeModule
 
-def setDatatypeElephino(datatype: str, sourGrapes: Optional[bool] = False) -> str:
+def setDatatypeElephino(datatype: str, sourGrapes: bool | None = False) -> str:
 	return reportDatatypeLimit('elephino', datatype, sourGrapes)
 
-def setDatatypeFoldsTotal(datatype: str, sourGrapes: Optional[bool] = False) -> str:
+def setDatatypeFoldsTotal(datatype: str, sourGrapes: bool | None = False) -> str:
 	return reportDatatypeLimit('foldsTotal', datatype, sourGrapes)
 
-def setDatatypeLeavesTotal(datatype: str, sourGrapes: Optional[bool] = False) -> str:
+def setDatatypeLeavesTotal(datatype: str, sourGrapes: bool | None = False) -> str:
 	return reportDatatypeLimit('leavesTotal', datatype, sourGrapes)
 
 def _get_datatype(identifier: str) -> str:
@@ -104,13 +92,13 @@ def getDatatypeModule() -> str:
 		_datatypeModule = _datatypeModuleDEFAULT
 	return _datatypeModule
 
-def setInStone(identifier: str) -> Type[Any]:
-	datatypeModule = getDatatypeModule()
-	datatypeStr = _get_datatype(identifier)
-	return cast(Type[Any], getattr(eval(datatypeModule), datatypeStr))
+def setInStone(identifier: str) -> type[Any]:
+	datatypeModule: str = getDatatypeModule()
+	datatypeStr: str = _get_datatype(identifier)
+	return cast(type[Any], getattr(eval(datatypeModule), datatypeStr))
 
-def hackSSOTdtype(identifier: str) -> Type[Any]:
-	_hackSSOTdtype={
+def hackSSOTdtype(identifier: str) -> type[Any]:
+	_hackSSOTdtype: dict[str, str]={
 	'connectionGraph': 	'dtypeLeavesTotal',
 	'dtypeElephino': 	'dtypeElephino',
 	'dtypeFoldsTotal': 	'dtypeFoldsTotal',
@@ -121,7 +109,7 @@ def hackSSOTdtype(identifier: str) -> Type[Any]:
 	'my': 				'dtypeElephino',
 	'track': 			'dtypeElephino',
 	}
-	RubeGoldBerg = _hackSSOTdtype[identifier]
+	RubeGoldBerg: str = _hackSSOTdtype[identifier]
 	if RubeGoldBerg == 'dtypeElephino':
 		return setInStone('elephino')
 	elif RubeGoldBerg == 'dtypeFoldsTotal':
@@ -131,7 +119,7 @@ def hackSSOTdtype(identifier: str) -> Type[Any]:
 	raise Exception("Dude, you forgot to set a value in `hackSSOTdtype`.")
 
 def hackSSOTdatatype(identifier: str) -> str:
-	_hackSSOTdatatype={
+	_hackSSOTdatatype: dict[str, str]={
 	'connectionGraph':	 		'datatypeLeavesTotal',
 	'countDimensionsGapped': 	'datatypeLeavesTotal',
 	'datatypeElephino': 		'datatypeElephino',
@@ -158,7 +146,7 @@ def hackSSOTdatatype(identifier: str) -> str:
 	'taskIndex': 				'datatypeLeavesTotal',
 	'track':	 				'datatypeElephino',
 	}
-	RubeGoldBerg = _hackSSOTdatatype[identifier]
+	RubeGoldBerg: str = _hackSSOTdatatype[identifier]
 	if RubeGoldBerg == 'datatypeElephino':
 		return _get_datatype('elephino')
 	elif RubeGoldBerg == 'datatypeFoldsTotal':

{mapFolding-0.4.3.dist-info → mapFolding-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.4.3
+Version: 0.5.1
 Summary: Count distinct ways to fold a map (or a strip of stamps)
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -33,12 +33,14 @@ Requires-Dist: numpy
 Requires-Dist: Z0Z_tools
 Provides-Extra: testing
 Requires-Dist: autoflake; extra == "testing"
+Requires-Dist: mypy; extra == "testing"
 Requires-Dist: more_itertools; 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"
 Requires-Dist: python_minifier; extra == "testing"
+Requires-Dist: pyupgrade; extra == "testing"
 Requires-Dist: updateCitation; extra == "testing"
 
 # mapFolding: Algorithms for enumerating distinct map/stamp folding patterns 🗺️

mapFolding-0.5.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+mapFolding/__init__.py,sha256=FmpYlbGIZ4Pkt5Qr49JRBWdPRX9be4dYNlEV1ZXkmKU,2620
+mapFolding/basecamp.py,sha256=eU-9XQ9aOpgOcpVSTlbQ_XZEYsmfx1h6gESTgvP3RrI,3707
+mapFolding/beDRY.py,sha256=_NswGMIkF77akOSEJQqbOQOMwwrAL0c9yJi5bTZUBzw,17027
+mapFolding/oeis.py,sha256=ekXTb5P2GUkVgVsxWb23nukl8Pg97kdyU3-pePq7EQA,11393
+mapFolding/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/theDao.py,sha256=64dlLhrdtNbZAXMbqcZhGAE0ZwgqYRt8nT1on46J-cc,12611
+mapFolding/theSSOT.py,sha256=u7VXbqGasrTomxI771bQ7kURMpfn_ph6Y8ac8Rf70hw,5866
+mapFolding/theSSOTdatatypes.py,sha256=-p9B5ikWPKqztnmDDg6NKAdys7qwiNU2c1oCbGXAf5Q,5714
+mapFolding-0.5.1.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapFolding-0.5.1.dist-info/METADATA,sha256=UJsh0vVsMCGhX3ORFIrrVCLSQDDGJeGC_QrUjJeKpB4,7718
+mapFolding-0.5.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.5.1.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.5.1.dist-info/top_level.txt,sha256=aG3bjFBoxxuaV3Iu1wZAd241Ubs3cdaJtKYBQBDIjsg,11
+mapFolding-0.5.1.dist-info/RECORD,,

{mapFolding-0.4.3.dist-info → mapFolding-0.5.1.dist-info}/top_level.txt

@@ -1,2 +1 @@
 mapFolding
-tests