mapFolding 0.3.7__py3-none-any.whl → 0.3.9__py3-none-any.whl

mapFolding/theDao.py

@@ -0,0 +1,214 @@
+from mapFolding import indexMy, indexTrack
+from numpy import integer
+from numpy.typing import NDArray
+from typing import Any, Tuple
+import numba
+import numpy
+
+def activeGapIncrement(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+    my[indexMy.gap1ndex.value] += 1
+
+def activeLeafGreaterThan0Condition(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+    return my[indexMy.leaf1ndex.value]
+
+def activeLeafGreaterThanLeavesTotalCondition(foldGroups: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+    return my[indexMy.leaf1ndex.value] > foldGroups[-1]
+
+def activeLeafIsTheFirstLeafCondition(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+    return my[indexMy.leaf1ndex.value] <= 1
+
+def allDimensionsAreUnconstrained(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+    return not my[indexMy.dimensionsUnconstrained.value]
+
+def backtrack(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.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: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.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: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+    my[indexMy.gap1ndexCeiling.value] += 1
+
+def countGaps(gapsWhere: 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]]]) -> 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: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+    my[indexMy.indexDimension.value] += 1
+
+def dimensionsUnconstrainedCondition(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.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: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+    my[indexMy.dimensionsUnconstrained.value] -= 1
+
+def filterCommonGaps(gapsWhere: 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]]]) -> 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: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.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: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+    my[indexMy.indexMiniGap.value] += 1
+
+def indexMiniGapInitialization(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+    my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
+
+def insertUnconstrainedLeaf(gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.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: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> Any:
+    return track[indexTrack.leafBelow.value, 0] == 1
+
+def leafConnecteeInitialization(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+    my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
+
+def leafConnecteeUpdate(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.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: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+    return my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]
+
+def loopingTheDimensions(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+    return my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]
+
+def loopingToActiveGapCeiling(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+    return my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]
+
+def placeLeaf(gapsWhere: 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]]]) -> 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: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+    return my[indexMy.leaf1ndex.value]
+
+def thereAreComputationDivisionsYouMightSkip(my: numpy.ndarray[Tuple[int], numpy.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: numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]]
+                    , gapsWhere: 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]]]) -> 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: 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]]]
+                    , my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]
+                    , track: numpy.ndarray[Tuple[int, int], numpy.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: 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]]], my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.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: 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]]]
+                ) -> 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,269 @@
+from collections import defaultdict
+from numpy import integer
+from types import ModuleType
+from typing import Any, Callable, Dict, Final, Optional, Tuple, Type, TypedDict, cast
+import enum
+import numba
+import numpy
+import numpy.typing
+import pathlib
+import sys
+
+"""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 getPathJobDEFAULT() -> 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()
+
+class ParametersNumba(TypedDict):
+    _nrt: bool
+    boundscheck: bool
+    cache: bool
+    error_model: str
+    fastmath: bool
+    forceinline: bool
+    inline: str
+    looplift: bool
+    no_cfunc_wrapper: bool
+    no_cpython_wrapper: bool
+    nopython: bool
+    parallel: bool
+
+parametersNumbaDEFAULT: Final[ParametersNumba] = {
+    '_nrt': True,
+    'boundscheck': False,
+    'cache': True,
+    'error_model': 'numpy',
+    'fastmath': True,
+    'forceinline': False,
+    'inline': 'never',
+    'looplift': False,
+    'no_cfunc_wrapper': True,
+    'no_cpython_wrapper': True,
+    'nopython': True,
+    'parallel': False,
+}
+
+"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`.")