mapFolding 0.3.8__py3-none-any.whl → 0.3.10__py3-none-any.whl

mapFolding/theDao.py

@@ -0,0 +1,213 @@
+from mapFolding import indexMy, indexTrack
+from numpy import dtype, integer, ndarray
+from typing import Any, Tuple
+import numba
+import numpy
+
+def activeGapIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+    my[indexMy.gap1ndex.value] += 1
+
+def activeLeafGreaterThan0Condition(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+    return my[indexMy.leaf1ndex.value]
+
+def activeLeafGreaterThanLeavesTotalCondition(foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+    return my[indexMy.leaf1ndex.value] > foldGroups[-1]
+
+def activeLeafIsTheFirstLeafCondition(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+    return my[indexMy.leaf1ndex.value] <= 1
+
+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:
+    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 backtrackCondition(my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> Any:
+    return my[indexMy.leaf1ndex.value] and my[indexMy.gap1ndex.value] == track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
+
+def gap1ndexCeilingIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+    my[indexMy.gap1ndexCeiling.value] += 1
+
+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:
+        gap1ndexCeilingIncrement(my=my)
+    track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
+
+def dimension1ndexIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+    my[indexMy.indexDimension.value] += 1
+
+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 dimensionsUnconstrainedDecrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+    my[indexMy.dimensionsUnconstrained.value] -= 1
+
+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]:
+        activeGapIncrement(my=my)
+    track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
+
+def findGapsInitializeVariables(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 indexMiniGapIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+    my[indexMy.indexMiniGap.value] += 1
+
+def indexMiniGapInitialization(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+    my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
+
+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 leafBelowSentinelIs1Condition(track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> Any:
+    return track[indexTrack.leafBelow.value, 0] == 1
+
+def leafConnecteeInitialization(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 leafConnecteeUpdate(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 loopingLeavesConnectedToActiveLeaf(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+    return my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]
+
+def loopingTheDimensions(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+    return my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]
+
+def loopingToActiveGapCeiling(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+    return my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]
+
+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]]]
+    track[indexTrack.leafBelow.value, track[indexTrack.leafAbove.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
+    track[indexTrack.leafAbove.value, track[indexTrack.leafBelow.value, my[indexMy.leaf1ndex.value]]] = my[indexMy.leaf1ndex.value]
+    track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
+    my[indexMy.leaf1ndex.value] += 1
+
+def placeLeafCondition(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+    return my[indexMy.leaf1ndex.value]
+
+def thereAreComputationDivisionsYouMightSkip(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 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 activeLeafGreaterThan0Condition(my=my):
+        if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
+            findGapsInitializeVariables(my=my, track=track)
+            while loopingTheDimensions(my=my):
+                if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
+                    dimensionsUnconstrainedDecrement(my=my)
+                else:
+                    leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
+                    while loopingLeavesConnectedToActiveLeaf(my=my):
+                        countGaps(gapsWhere=gapsWhere, my=my, track=track)
+                        leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
+                dimension1ndexIncrement(my=my)
+            if allDimensionsAreUnconstrained(my=my):
+                insertUnconstrainedLeaf(gapsWhere=gapsWhere, my=my)
+            indexMiniGapInitialization(my=my)
+            while loopingToActiveGapCeiling(my=my):
+                filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
+                indexMiniGapIncrement(my=my)
+        if placeLeafCondition(my=my):
+            placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
+        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]]]) -> None:
+    gapsWherePARALLEL = gapsWhere.copy()
+    myPARALLEL = my.copy()
+    trackPARALLEL = track.copy()
+    taskDivisionsPrange = myPARALLEL[indexMy.taskDivisions.value]
+    for indexSherpa in numba.prange(taskDivisionsPrange):
+        groupsOfFolds: int = 0
+        gapsWhere = gapsWherePARALLEL.copy()
+        my = myPARALLEL.copy()
+        my[indexMy.taskIndex.value] = indexSherpa
+        track = trackPARALLEL.copy()
+        while activeLeafGreaterThan0Condition(my=my):
+            if activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track):
+                if activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my):
+                    groupsOfFolds += 1
+                else:
+                    findGapsInitializeVariables(my=my, track=track)
+                    while loopingTheDimensions(my=my):
+                        if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
+                            dimensionsUnconstrainedDecrement(my=my)
+                        else:
+                            leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
+                            while loopingLeavesConnectedToActiveLeaf(my=my):
+                                if thereAreComputationDivisionsYouMightSkip(my=my):
+                                    countGaps(gapsWhere=gapsWhere, my=my, track=track)
+                                leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
+                        dimension1ndexIncrement(my=my)
+                    indexMiniGapInitialization(my=my)
+                    while loopingToActiveGapCeiling(my=my):
+                        filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
+                        indexMiniGapIncrement(my=my)
+            while backtrackCondition(my=my, track=track):
+                backtrack(my=my, track=track)
+            if placeLeafCondition(my=my):
+                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]]]) -> None:
+    groupsOfFolds: int = 0
+    doFindGaps = True
+    while activeLeafGreaterThan0Condition(my=my):
+        if ((doFindGaps := activeLeafIsTheFirstLeafCondition(my=my) or leafBelowSentinelIs1Condition(track=track))
+                and activeLeafGreaterThanLeavesTotalCondition(foldGroups=foldGroups, my=my)):
+            groupsOfFolds += 1
+        elif doFindGaps:
+            findGapsInitializeVariables(my=my, track=track)
+            while loopingTheDimensions(my=my):
+                if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
+                    dimensionsUnconstrainedDecrement(my=my)
+                else:
+                    leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
+                    while loopingLeavesConnectedToActiveLeaf(my=my):
+                        countGaps(gapsWhere=gapsWhere, my=my, track=track)
+                        leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
+                dimension1ndexIncrement(my=my)
+            indexMiniGapInitialization(my=my)
+            while loopingToActiveGapCeiling(my=my):
+                filterCommonGaps(gapsWhere=gapsWhere, my=my, track=track)
+                indexMiniGapIncrement(my=my)
+        while backtrackCondition(my=my, track=track):
+            backtrack(my=my, track=track)
+        if placeLeafCondition(my=my):
+            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]]]
+                ) -> None:
+    countInitialize(connectionGraph, gapsWhere, my, track)
+
+    if my[indexMy.taskDivisions.value] > 0:
+        countParallel(connectionGraph, foldGroups, gapsWhere, my, track)
+    else:
+        countSequential(connectionGraph, foldGroups, gapsWhere, my, track)

mapFolding/theSSOT.py

@@ -0,0 +1,251 @@
+from collections import defaultdict
+from mapFolding.theSSOTnumba import *
+from numpy import integer
+from types import ModuleType
+from typing import Any, Callable, Dict, Final, Optional, Tuple, Type, TYPE_CHECKING, cast
+import enum
+import numba
+import numpy
+import numpy.typing
+import pathlib
+import sys
+
+try:
+    from typing import NotRequired
+except ImportError:
+    from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    from typing import TypedDict
+else:
+    TypedDict = dict
+
+"""I have hobbled together:
+TypedDict, Enum, defaultdict, and lookup dictionaries to make DIY immutability and delayed realization/instantiation.
+Nevertheless, I am both confident that all of these processes will be replaced and completely ignorant of what will replace them."""
+
+"""Technical concepts I am likely using and likely want to use more effectively:
+- Configuration Registry
+- Write-Once, Read-Many (WORM) / Immutable Initialization
+- Lazy Initialization
+- Separation of Concerns: in the sense that configuration is separated from business logic
+
+Furthermore, I want to more clearly divorce the concept of a single _source_ of (a) truth from
+the _authority_ of that truth. The analogy to a registry of ownership is still apt: the registry
+is, at most, a single (or centralized) source of truth, but it is merely the place to register/record
+the truth determined by some other authority.
+
+And, I almost certainly want to change the semiotics from "authority" (of truth) to "power" (to create a truth).
+Here, "power" is a direct analogy to https://hunterthinks.com/opinion/a-hohfeldian-primer.
+"""
+
+myPackageNameIs = "mapFolding"
+
+moduleOfSyntheticModules = "syntheticModules"
+
+def getPathPackage() -> pathlib.Path:
+    import importlib, inspect
+    pathPackage = pathlib.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"
+    else:
+        pathJobDEFAULT = getPathPackage() / "jobs"
+    return pathJobDEFAULT
+
+def getPathSyntheticModules() -> pathlib.Path:
+    pathSyntheticModules = getPathPackage() / moduleOfSyntheticModules
+    return pathSyntheticModules
+
+def getAlgorithmSource() -> ModuleType:
+    from mapFolding import theDao
+    return theDao
+
+def getAlgorithmCallable() -> Callable[..., None]:
+    algorithmSource = getAlgorithmSource()
+    return cast(Callable[..., None], algorithmSource.doTheNeedful)
+
+def getDispatcherCallable() -> Callable[..., None]:
+    from mapFolding.syntheticModules import numba_doTheNeedful
+    return cast(Callable[..., None], numba_doTheNeedful.doTheNeedful)
+
+# NOTE I want this _concept_ to be well implemented and usable everywhere: Python, Numba, Jax, CUDA, idc
+class computationState(TypedDict):
+    connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]]
+    foldGroups: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
+    gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
+    mapShape: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
+    my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
+    track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]
+
+@enum.verify(enum.CONTINUOUS, enum.UNIQUE) if sys.version_info >= (3, 11) else lambda x: x
+class EnumIndices(enum.IntEnum):
+    """Base class for index enums."""
+    @staticmethod
+    def _generate_next_value_(name: str, start: int, count: int, last_values: list[Any]) -> int:
+        """0-indexed."""
+        return count
+
+    def __index__(self) -> int:
+        """Adapt enum to the ultra-rare event of indexing a NumPy 'ndarray', which is not the
+        same as `array.array`. See NumPy.org; I think it will be very popular someday."""
+        return self.value
+
+class indexMy(EnumIndices):
+    """Indices for scalar values."""
+    dimensionsTotal = enum.auto()
+    dimensionsUnconstrained = enum.auto()
+    gap1ndex = enum.auto()
+    gap1ndexCeiling = enum.auto()
+    indexDimension = enum.auto()
+    indexLeaf = enum.auto()
+    indexMiniGap = enum.auto()
+    leaf1ndex = enum.auto()
+    leafConnectee = enum.auto()
+    taskDivisions = enum.auto()
+    taskIndex = enum.auto()
+
+class indexTrack(EnumIndices):
+    """Indices for state tracking array."""
+    leafAbove = enum.auto()
+    leafBelow = enum.auto()
+    countDimensionsGapped = enum.auto()
+    gapRangeStart = enum.auto()
+
+"delay realization/instantiation until a concrete value is desired"
+"moment of truth: when the value is needed, not when the value is defined"
+
+"""What is a (not too complicated, integer) datatype?
+    - ecosystem/module
+        - must apathy|value|list of values
+        - mustn't apathy|value|list of values
+    - bit width
+        - bits maximum apathy|value
+        - bits minimum apathy|value
+        - magnitude maximum apathy|value
+        - ?magnitude minimum apathy|value
+    - signedness apathy|non-negative|non-positive|both
+    """
+
+_datatypeDefault: Final[Dict[str, str]] = {
+    'elephino': 'uint8',
+    'foldsTotal': 'int64',
+    'leavesTotal': 'uint8',
+}
+_datatypeModule = ''
+_datatypeModuleDEFAULT: Final[str] = 'numpy'
+
+_datatype: Dict[str, str] = defaultdict(str)
+
+def reportDatatypeLimit(identifier: str, datatype: str, sourGrapes: Optional[bool] = False) -> str:
+    global _datatype
+    if not _datatype[identifier]:
+        _datatype[identifier] = datatype
+    elif _datatype[identifier] == datatype:
+        pass
+    elif sourGrapes:
+        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:
+    global _datatypeModule
+    if not _datatypeModule:
+        _datatypeModule = datatypeModule
+    elif _datatypeModule == datatypeModule:
+        pass
+    elif sourGrapes:
+        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:
+    return reportDatatypeLimit('elephino', datatype, sourGrapes)
+
+def setDatatypeFoldsTotal(datatype: str, sourGrapes: Optional[bool] = False) -> str:
+    return reportDatatypeLimit('foldsTotal', datatype, sourGrapes)
+
+def setDatatypeLeavesTotal(datatype: str, sourGrapes: Optional[bool] = False) -> str:
+    return reportDatatypeLimit('leavesTotal', datatype, sourGrapes)
+
+def _get_datatype(identifier: str) -> str:
+    global _datatype
+    if not _datatype[identifier]:
+        if identifier in indexMy._member_names_:
+            _datatype[identifier] = _datatypeDefault.get(identifier) or _get_datatype('elephino')
+        elif identifier in indexTrack._member_names_:
+            _datatype[identifier] = _datatypeDefault.get(identifier) or _get_datatype('elephino')
+        else:
+            _datatype[identifier] = _datatypeDefault.get(identifier) or _get_datatype('foldsTotal')
+    return _datatype[identifier]
+
+def _getDatatypeModule() -> str:
+    global _datatypeModule
+    if not _datatypeModule:
+        _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 hackSSOTdtype(identifier: str) -> Type[Any]:
+    _hackSSOTdtype={
+    'connectionGraph': 'dtypeLeavesTotal',
+    'dtypeElephino': 'dtypeElephino',
+    'dtypeFoldsTotal': 'dtypeFoldsTotal',
+    'dtypeLeavesTotal': 'dtypeLeavesTotal',
+    'foldGroups': 'dtypeFoldsTotal',
+    'gapsWhere': 'dtypeLeavesTotal',
+    'mapShape': 'dtypeLeavesTotal',
+    'my': 'dtypeElephino',
+    'track': 'dtypeElephino',
+    }
+    RubeGoldBerg = _hackSSOTdtype[identifier]
+    if RubeGoldBerg == 'dtypeElephino':
+        return setInStone('elephino')
+    elif RubeGoldBerg == 'dtypeFoldsTotal':
+        return setInStone('foldsTotal')
+    elif RubeGoldBerg == 'dtypeLeavesTotal':
+        return setInStone('leavesTotal')
+    raise Exception("Dude, you forgot to set a value in `hackSSOTdtype`.")
+
+def hackSSOTdatatype(identifier: str) -> str:
+    _hackSSOTdatatype={
+    'connectionGraph': 'datatypeLeavesTotal',
+    'countDimensionsGapped': 'datatypeLeavesTotal',
+    'datatypeElephino': 'datatypeElephino',
+    'datatypeFoldsTotal': 'datatypeFoldsTotal',
+    'datatypeLeavesTotal': 'datatypeLeavesTotal',
+    'dimensionsTotal': 'datatypeLeavesTotal',
+    'dimensionsUnconstrained': 'datatypeLeavesTotal',
+    'foldGroups': 'datatypeFoldsTotal',
+    'gap1ndex': 'datatypeLeavesTotal',
+    'gap1ndexCeiling': 'datatypeElephino',
+    'gapRangeStart': 'datatypeElephino',
+    'gapsWhere': 'datatypeLeavesTotal',
+    'groupsOfFolds': 'datatypeFoldsTotal',
+    'indexDimension': 'datatypeLeavesTotal',
+    'indexLeaf': 'datatypeLeavesTotal',
+    'indexMiniGap': 'datatypeElephino',
+    'leaf1ndex': 'datatypeLeavesTotal',
+    'leafAbove': 'datatypeLeavesTotal',
+    'leafBelow': 'datatypeLeavesTotal',
+    'leafConnectee': 'datatypeLeavesTotal',
+    'mapShape': 'datatypeLeavesTotal',
+    'my': 'datatypeElephino',
+    'taskDivisions': 'datatypeLeavesTotal',
+    'taskIndex': 'datatypeLeavesTotal',
+    'track': 'datatypeElephino',
+    }
+    RubeGoldBerg = _hackSSOTdatatype[identifier]
+    if RubeGoldBerg == 'datatypeElephino':
+        return _get_datatype('elephino')
+    elif RubeGoldBerg == 'datatypeFoldsTotal':
+        return _get_datatype('foldsTotal')
+    elif RubeGoldBerg == 'datatypeLeavesTotal':
+        return _get_datatype('leavesTotal')
+    raise Exception("Dude, you forgot to set a value in `hackSSOTdatatype`.")

mapFolding/theSSOTnumba.py

@@ -0,0 +1,115 @@
+"""TODO learn how to use this efficiently and effectively to solve problems, be DRY, and have SSOT."""
+from typing import Final, TYPE_CHECKING, Dict, Any, Union, Callable, Tuple, Any
+import numba
+import numba.core.compiler
+try:
+    from typing import NotRequired
+except ImportError:
+    from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+    from typing import TypedDict
+else:
+    TypedDict = dict
+
+"""
+Old notes that are not entirely accurate.
+
+| **Option**              | **Description**                                     | **Why**               | **Size**        | **But**                  |
+| ----------------------- | --------------------------------------------------- | --------------------- | --------------- | ------------------------ |
+| `_dbg_extend_lifetimes` | Debug option to extend object lifetimes             | Debugging             |                 |                          |
+| `_dbg_optnone`          | Disable optimization for debugging                  | Debugging             |                 |                          |
+| `debug`                 | Enable debug mode with additional checks            | Debugging             |                 |                          |
+| `no_rewrites`           | Disable AST rewrites optimization                   | Debugging             |                 |                          |
+| `boundscheck`           | Enable array bounds checking (slows execution)      | Error checking        | Larger          | Slower                   |
+| `error_model`           | Divide by zero: kill or chill?                      | Error checking        | ?               |                          |
+| `_nrt`                  | Enable No Runtime type checking                     | Startup speed         | Smaller         | No type protection       |
+| `fastmath`              | Reduce float potential precision                    | Float speed           | Smaller         | Discriminatory, untested |
+| `forceinline`           | Force function inlining                             | Reduce function calls | Likely larger   |                          |
+| `forceobj`              | Force object mode compilation                       | Inclusiveness         | Larger          | Slower execution         |
+| `inline`                | Algorithmically choose inlining                     | Speed                 | Slightly larger |                          |
+| `looplift`              | Enable loop lifting optimization                    | Speed (if applicable) | Larger          | Exclusionary             |
+| `no_cfunc_wrapper`      | Disable C function wrapper generation               | Size                  | Smaller         | Exclusionary             |
+| `no_cpython_wrapper`    | Disable Python C-API wrapper generation             | Size                  | Smallest        | Exclusionary             |
+
+"""
+
+# TODO try to implement all possible parameters, but use `NotRequired` for the more esoteric ones
+class ParametersNumba(TypedDict):
+    _dbg_extend_lifetimes: NotRequired[bool]
+    _dbg_optnone: NotRequired[bool]
+    _nrt: NotRequired[bool]
+    boundscheck: NotRequired[bool]
+    cache: bool
+    debug: NotRequired[bool]
+    error_model: str
+    fastmath: bool
+    forceinline: bool
+    forceobj: NotRequired[bool]
+    inline: str
+    locals: NotRequired[Dict[str, Any]]
+    looplift: bool
+    no_cfunc_wrapper: bool
+    no_cpython_wrapper: bool
+    no_rewrites: NotRequired[bool]
+    nogil: NotRequired[bool]
+    nopython: bool
+    parallel: bool
+    pipeline_class: NotRequired[numba.core.compiler.CompilerBase]
+    signature_or_function: NotRequired[Union[Any, Callable, str, Tuple]]
+    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,
+}
+"""For a production function: speed is irrelevant, error discovery is paramount, must be compatible with anything downstream."""
+
+parametersNumbaDEFAULT: Final[ParametersNumba] = {
+    '_nrt': True,
+    'boundscheck': False,
+    'cache': True,
+    'error_model': 'numpy',
+    'fastmath': True,
+    'forceinline': True,
+    'inline': 'always',
+    'looplift': False,
+    'no_cfunc_wrapper': False,
+    'no_cpython_wrapper': False,
+    'nopython': True,
+    'parallel': False,
+}
+"""Middle of the road: fast, lean, but will talk to non-jitted functions."""
+
+parametersNumbaParallelDEFAULT: Final[ParametersNumba] = {
+    **parametersNumbaDEFAULT,
+    '_nrt': True,
+    'parallel': True,
+}
+"""Middle of the road: fast, lean, but will talk to non-jitted functions."""
+
+parametersNumbaSuperJit: Final[ParametersNumba] = {
+    **parametersNumbaDEFAULT,
+    'no_cfunc_wrapper': True,
+    'no_cpython_wrapper': True,
+}
+"""Speed, no helmet, no talking to non-jitted functions."""
+
+parametersNumbaSuperJitParallel: Final[ParametersNumba] = {
+    **parametersNumbaSuperJit,
+    '_nrt': True,
+    'parallel': True,
+}
+"""Speed, no helmet, concurrency, no talking to non-jitted functions.
+Claude says, "The NRT is Numba's memory management system that handles memory allocation and deallocation for array operations. Because of array copying, you need to have NRT enabled." IDK which AI assistant autocompleted this, but, "The NRT is a bit slower than the default memory management system, but it's necessary for certain operations."
+"""