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

mapFolding/syntheticModules/numba_doTheNeedful.py

@@ -1,6 +1,5 @@
 from mapFolding import indexMy, indexTrack
-from numpy import integer
-from numpy.typing import NDArray
+from numpy import dtype, integer, ndarray
 from typing import Any, Tuple
 import numba
 import numpy
@@ -8,24 +7,22 @@ from mapFolding.syntheticModules.numba_countInitialize import countInitialize
 from mapFolding.syntheticModules.numba_countParallel import countParallel
 from mapFolding.syntheticModules.numba_countSequential import countSequential
 
-@numba.jit((numba.uint8[:, :, ::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]))
-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:
-    """
-        What in tarnation is this stupid module and function?
+@numba.jit((numba.uint8[:, :, ::1], numba.int64[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[::1], numba.uint8[:, ::1]), _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)
+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:
+    """What in tarnation is this stupid module and function?
 
-        - This function is not in the same module as `countFolds` so that we can delay Numba just-in-time (jit) compilation of this function and the finalization of its settings until we are ready.
-        - This function is not in the same module as the next function, which does the hard work, so that we can delay `numba.jit` compilation of the next function.
-        - This function is "jitted" but the next function is super jitted, which makes it too arrogant to talk to plebian Python functions. It will, however, reluctantly talk to basic jitted functions.
-        - So this module can talk to the next function, and because this module isn't as arrogant, it will talk to the low-class `countFolds` that called this function. Well, with a few restrictions, of course:
-            - No `TypedDict`
-            - The plebs must clean up their own memory problems
-            - No oversized integers
-            - No global variables, only global constants
-            - It won't accept pleb nonlocal variables either
-            - Python "class": they are all inferior to the jit class
-            - No `**kwargs`
-            - and just a few dozen-jillion other things.
-        """
+    - This function is not in the same module as `countFolds` so that we can delay Numba just-in-time (jit) compilation of this function and the finalization of its settings until we are ready.
+    - This function is not in the same module as the next function, which does the hard work, so that we can delay `numba.jit` compilation of the next function.
+    - This function is "jitted" but the next function is super jitted, which makes it too arrogant to talk to plebian Python functions. It will, however, reluctantly talk to basic jitted functions.
+    - So this module can talk to the next function, and because this module isn't as arrogant, it will talk to the low-class `countFolds` that called this function. Well, with a few restrictions, of course:
+        - No `TypedDict`
+        - The plebs must clean up their own memory problems
+        - No oversized integers
+        - No global variables, only global constants
+        - It won't accept pleb nonlocal variables either
+        - Python "class": they are all inferior to the jit class
+        - No `**kwargs`
+        - and just a few dozen-jillion other things."""
     countInitialize(connectionGraph, gapsWhere, my, track)
     if my[indexMy.taskDivisions.value] > 0:
         countParallel(connectionGraph, foldGroups, gapsWhere, my, track)

mapFolding/theDao.py

@@ -1,94 +1,93 @@
 from mapFolding import indexMy, indexTrack
-from numpy import integer
-from numpy.typing import NDArray
+from numpy import dtype, integer, ndarray
 from typing import Any, Tuple
 import numba
 import numpy
 
-def activeGapIncrement(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+def activeGapIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
     my[indexMy.gap1ndex.value] += 1
 
-def activeLeafGreaterThan0Condition(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+def activeLeafGreaterThan0Condition(my: ndarray[Tuple[int], 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:
+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: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+def activeLeafIsTheFirstLeafCondition(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
     return my[indexMy.leaf1ndex.value] <= 1
 
-def allDimensionsAreUnconstrained(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+def allDimensionsAreUnconstrained(my: ndarray[Tuple[int], 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:
+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: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> Any:
+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: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+def gap1ndexCeilingIncrement(my: ndarray[Tuple[int], 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:
+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: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+def dimension1ndexIncrement(my: ndarray[Tuple[int], 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:
+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: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+def dimensionsUnconstrainedDecrement(my: ndarray[Tuple[int], 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:
+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: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], track: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> None:
+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: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+def indexMiniGapIncrement(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
     my[indexMy.indexMiniGap.value] += 1
 
-def indexMiniGapInitialization(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> None:
+def indexMiniGapInitialization(my: ndarray[Tuple[int], 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:
+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: numpy.ndarray[Tuple[int, int], numpy.dtype[integer[Any]]]) -> Any:
+def leafBelowSentinelIs1Condition(track: ndarray[Tuple[int, int], 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:
+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: 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:
+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: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+def loopingLeavesConnectedToActiveLeaf(my: ndarray[Tuple[int], 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:
+def loopingTheDimensions(my: ndarray[Tuple[int], 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:
+def loopingToActiveGapCeiling(my: ndarray[Tuple[int], 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:
+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]]]
@@ -97,16 +96,16 @@ def placeLeaf(gapsWhere: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]], m
     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:
+def placeLeafCondition(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
     return my[indexMy.leaf1ndex.value]
 
-def thereAreComputationDivisionsYouMightSkip(my: numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]) -> Any:
+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: 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:
+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)
@@ -130,11 +129,11 @@ def countInitialize(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.d
         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:
+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()
@@ -171,7 +170,7 @@ def countParallel(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.dty
                 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:
+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):
@@ -199,12 +198,12 @@ def countSequential(connectionGraph: numpy.ndarray[Tuple[int, int, int], numpy.d
             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]]]
+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,7 +1,8 @@
 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, TypedDict, cast
+from typing import Any, Callable, Dict, Final, Optional, Tuple, Type, TYPE_CHECKING, cast
 import enum
 import numba
 import numpy
@@ -9,6 +10,16 @@ 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."""
@@ -39,7 +50,7 @@ def getPathPackage() -> pathlib.Path:
         pathPackage = pathPackage.parent
     return pathPackage
 
-def getPathJobDEFAULT() -> pathlib.Path:
+def getPathJobRootDEFAULT() -> pathlib.Path:
     if 'google.colab' in sys.modules:
         pathJobDEFAULT = pathlib.Path("/content/drive/MyDrive") / "jobs"
     else:
@@ -105,35 +116,6 @@ class indexTrack(EnumIndices):
     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"
 

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."
+"""

{mapFolding-0.3.9.dist-info → mapFolding-0.3.10.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.3.9
+Version: 0.3.10
 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
@@ -25,11 +25,6 @@ License-File: LICENSE
 Requires-Dist: numba
 Requires-Dist: numpy
 Requires-Dist: Z0Z_tools
-Provides-Extra: benchmark
-Requires-Dist: ipywidgets; extra == "benchmark"
-Requires-Dist: jupyter; extra == "benchmark"
-Requires-Dist: pandas; extra == "benchmark"
-Requires-Dist: tqdm; extra == "benchmark"
 Provides-Extra: testing
 Requires-Dist: more_itertools; extra == "testing"
 Requires-Dist: mypy; extra == "testing"
@@ -39,7 +34,6 @@ Requires-Dist: pytest-mypy; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: python_minifier; extra == "testing"
-Requires-Dist: tomli; extra == "testing"
 Requires-Dist: types-setuptools; extra == "testing"
 
 # Algorithm(s) for counting distinct ways to fold a map (or a strip of stamps)

mapFolding-0.3.10.dist-info/RECORD

@@ -0,0 +1,40 @@
+mapFolding/__init__.py,sha256=-6hIljicU0Ql3yWpw8prpLGSQGUCHsNrSuf7zDNs_Ko,1169
+mapFolding/basecamp.py,sha256=DISWQIzAF7o7WPUn2QZxMu3Ruwc0zkVPgceeUTUcfqo,3988
+mapFolding/beDRY.py,sha256=Gsj7NEBztbPoKszPibhW6pO9xwjAIPgaW411A_Quwz8,18654
+mapFolding/oeis.py,sha256=2kFIAnBu0Bs4rHceXqs1RyyEBM6A_5fR5562B4ShxVg,12311
+mapFolding/theDao.py,sha256=0ySeHdmNXA1X3aKs7tdJ1cQes_rWf9Vp0tdC1zSXf6U,13669
+mapFolding/theSSOT.py,sha256=vtqhR1E6wwqVKtGKBY0UBAGRYu6x3gtPBloBzzuZi6M,9826
+mapFolding/theSSOTnumba.py,sha256=ex_NnkGd3GWUQVrtWxKzsNmiSm2e091uhVmiZn0aPew,5568
+mapFolding/reference/flattened.py,sha256=6blZ2Y9G8mu1F3gV8SKndPE398t2VVFlsgKlyeJ765A,16538
+mapFolding/reference/hunterNumba.py,sha256=HWndRgsajOf76rbb2LDNEZ6itsdYbyV-k3wgOFjeR6c,7104
+mapFolding/reference/irvineJavaPort.py,sha256=Sj-63Z-OsGuDoEBXuxyjRrNmmyl0d7Yz_XuY7I47Oyg,4250
+mapFolding/reference/jax.py,sha256=rojyK80lOATtbzxjGOHWHZngQa47CXCLJHZwIdN2MwI,14955
+mapFolding/reference/lunnan.py,sha256=XEcql_gxvCCghb6Or3qwmPbn4IZUbZTaSmw_fUjRxZE,5037
+mapFolding/reference/lunnanNumpy.py,sha256=HqDgSwTOZA-G0oophOEfc4zs25Mv4yw2aoF1v8miOLk,4653
+mapFolding/reference/lunnanWhile.py,sha256=7NY2IKO5XBgol0aWWF_Fi-7oTL9pvu_z6lB0TF1uVHk,4063
+mapFolding/reference/rotatedEntryPoint.py,sha256=z0QyDQtnMvXNj5ntWzzJUQUMFm1-xHGLVhtYzwmczUI,11530
+mapFolding/reference/total_countPlus1vsPlusN.py,sha256=usenM8Yn_G1dqlPl7NKKkcnbohBZVZBXTQRm2S3_EDA,8106
+mapFolding/someAssemblyRequired/__init__.py,sha256=O-r-Oy7HK8RtIhXjBo99BPn7kOY-zDo4r1X_B3CYscI,121
+mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=FtJzw2pZS3A4NimWdZsegXaU-vKeCw8m67kcfb5wvGM,894
+mapFolding/someAssemblyRequired/makeJob.py,sha256=j62UMwwGV3CtF0j6ByyCxOuRNDCtv3MqVGUEtBSsAfk,2589
+mapFolding/someAssemblyRequired/synthesizeJobNumba.py,sha256=fwWjayhHyef9UxpjGDpLKoCvkvwtVMITKczlEedUXpE,19358
+mapFolding/someAssemblyRequired/synthesizeModuleJAX.py,sha256=TU8lgoMr77pctvvmlfbT-XstQk4j6Jo8JcIuvAiCuMU,1316
+mapFolding/someAssemblyRequired/synthesizeModulesNumba.py,sha256=hg6FOJbaJcsiWrqv6sTqkxaXYkR_TKPyLS8sJGqRQB0,26460
+mapFolding/syntheticModules/numba_countInitialize.py,sha256=d_aptX7pbgLxiXJnr-t0W6znDXqX77r8clfKQOTZfBw,4210
+mapFolding/syntheticModules/numba_countParallel.py,sha256=W1157Xd8xwLXpRK82OMgL7AyFu0jh70_dHhrZ0mtYIs,5416
+mapFolding/syntheticModules/numba_countSequential.py,sha256=Se4FNea9XOEfTVRJkNNdJHpsKu0CcLJGKmqUHvMqmrU,3593
+mapFolding/syntheticModules/numba_doTheNeedful.py,sha256=DyfNpKHWSUD6vqL3gcv80eLvKeibtUm8aa-Zu_weuqE,2521
+tests/__init__.py,sha256=eg9smg-6VblOr0kisM40CpGnuDtU2JgEEWGDTFVOlW8,57
+tests/conftest.py,sha256=tGRYkHfwVKGoMklBSQiTD8cTu-QL1wUSZd-52Xlnm50,7676
+tests/conftest_tmpRegistry.py,sha256=0XpGe7s2aJcjdEAqKs10vceW0_JAaK-Rp1UoPaL-BIo,2450
+tests/conftest_uniformTests.py,sha256=2v9UJbKgbrus3UyWXsanEHLksBskbnP0MD8iKVPaIBo,2178
+tests/test_oeis.py,sha256=F89HJ27y54NXcR2wMeBS4ea6R7EaEqpF_GkcU-BrsK4,5694
+tests/test_other.py,sha256=UpS0_WUfWA3wONuZwip5AMmzNmmBwYD7reQDZ9ziL_o,12224
+tests/test_tasks.py,sha256=ap_tKjHUN95vjzKo3xzBAQ3kMbdMJ_XXbOv9YIBJ5pY,2826
+tests/test_types.py,sha256=HklNCGThFiqQ89AOMkE7YkcfAPiZE32DpD3GMDUPQVc,177
+mapFolding-0.3.10.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapFolding-0.3.10.dist-info/METADATA,sha256=GYvtSr3qWSvPYIrPAlZuQZmUIxIVt0vkPYIn-X7WOnc,7690
+mapFolding-0.3.10.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.3.10.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.3.10.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapFolding-0.3.10.dist-info/RECORD,,

tests/conftest.py

@@ -18,7 +18,7 @@ from mapFolding import *
 from mapFolding import basecamp
 from mapFolding import getAlgorithmCallable, getDispatcherCallable
 from mapFolding.beDRY import *
-from mapFolding.oeis import _getFilenameOEISbFile, _getOEISidValues
+from mapFolding.oeis import _getFilenameOEISbFile, _getOEISidValues, _getOEISidInformation
 from mapFolding.oeis import *
 from Z0Z_tools.pytestForYourUse import PytestFor_defineConcurrencyLimit, PytestFor_intInnit, PytestFor_oopsieKwargsie
 from typing import Any, Callable, ContextManager, Dict, Generator, List, Optional, Sequence, Set, Tuple, Type, Union
@@ -40,7 +40,7 @@ def makeDictionaryFoldsTotalKnown() -> Dict[Tuple[int,...], int]:
             dictionaryMapDimensionsToFoldsTotalKnown[tuple(dimensions)] = foldingsTotal
 
     # Are we in a place that has jobs?
-    pathJobDEFAULT = getPathJobDEFAULT()
+    pathJobDEFAULT = getPathJobRootDEFAULT()
     if pathJobDEFAULT.exists():
         # Are there foldsTotal files?
         for pathFilenameFoldsTotal in pathJobDEFAULT.rglob('*.foldsTotal'):
@@ -181,44 +181,3 @@ def useAlgorithmDirectly() -> Generator[None, Any, None]:
 
     # Restore original function
     basecamp.getDispatcherCallable = original_dispatcher
-
-"""
-Section: Prototype test structures before moving to uniformTests.py"""
-
-def prototypeCacheTest(
-    expected: Any,
-    setupCacheFile: Optional[Callable[[pathlib.Path, str], None]],
-    oeisID: str,
-    pathCache: pathlib.Path
-) -> None:
-    """Template for tests involving OEIS cache operations.
-
-    Parameters
-        expected: Expected value or exception from _getOEISidValues
-        setupCacheFile: Function to prepare the cache file before test
-        oeisID: OEIS ID to test
-        pathCache: Temporary cache directory path
-    """
-    pathFilenameCache = pathCache / _getFilenameOEISbFile(oeisID)
-
-    # Setup cache file if provided
-    if setupCacheFile:
-        setupCacheFile(pathFilenameCache, oeisID)
-
-    # Run test
-    try:
-        actual: Any = _getOEISidValues(oeisID)
-        messageActual = actual
-    except Exception as actualError:
-        actual = type(actualError)
-        messageActual = type(actualError).__name__
-
-    # Compare results
-    if isinstance(expected, type) and issubclass(expected, Exception):
-        messageExpected = expected.__name__
-        assert isinstance(actual, expected), uniformTestMessage(
-            messageExpected, messageActual, "_getOEISidValues", oeisID)
-    else:
-        messageExpected = expected
-        assert actual == expected, uniformTestMessage(
-            messageExpected, messageActual, "_getOEISidValues", oeisID)