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

tests/test_other.py

@@ -43,7 +43,11 @@ import sys
 	(range(3, 7), [3, 4, 5, 6], [3, 4, 5, 6], [3, 4, 5, 6], 360),  # range sequence type
 	(tuple([3, 5, 7]), [3, 5, 7], [3, 5, 7], [3, 5, 7], 105),  # tuple sequence type
 ])
-def test_listDimensionsAsParameter(listDimensions: None | List[str] | List[int] | List[float] | List[None] | List[bool] | List[List[int]] | List[complex] | range | tuple[int, ...], expected_intInnit: type[ValueError] | List[int] | type[TypeError], expected_parseListDimensions: type[ValueError] | List[int] | type[TypeError], expected_validateListDimensions: type[ValueError] | type[NotImplementedError] | List[int] | type[TypeError], expected_getLeavesTotal: type[ValueError] | int | type[TypeError] | type[OverflowError]) -> None:
+def test_listDimensionsAsParameter(listDimensions: None | list[str] | list[int] | list[float] | list[None] | list[bool] | list[list[int]] | list[complex] | range | tuple[int, ...],
+								expected_intInnit: type[ValueError] | list[int] | type[TypeError],
+								expected_parseListDimensions: type[ValueError] | list[int] | type[TypeError],
+								expected_validateListDimensions: type[ValueError] | type[NotImplementedError] | list[int] | type[TypeError],
+								expected_getLeavesTotal: type[ValueError] | int | type[TypeError] | type[OverflowError]) -> None:
 	"""Test both validateListDimensions and getLeavesTotal with the same inputs."""
 	standardizedEqualTo(expected_intInnit, intInnit, listDimensions)
 	standardizedEqualTo(expected_parseListDimensions, parseDimensions, listDimensions)
@@ -82,14 +86,14 @@ def testOopsieKwargsie(nameOfTest: str, callablePytest: Callable[[], None]) -> N
 def test_setCPUlimit(CPUlimit: None | float | bool | Literal[4] | Literal[-2] | Literal[0] | Literal[1], expectedLimit: Any | int) -> None:
 	standardizedEqualTo(expectedLimit, setCPUlimit, CPUlimit)
 
-def test_makeConnectionGraph_nonNegative(listDimensionsTestFunctionality: List[int]) -> None:
+def test_makeConnectionGraph_nonNegative(listDimensionsTestFunctionality: list[int]) -> None:
 	connectionGraph = makeConnectionGraph(listDimensionsTestFunctionality)
 	assert numpy.all(connectionGraph >= 0), "All values in the connection graph should be non-negative."
 
 @pytest.fixture
-def parameterIterator() -> Callable[[List[int]], Generator[Dict[str, Any], None, None]]:
+def parameterIterator() -> Callable[[list[int]], Generator[dict[str, Any], None, None]]:
 	"""Generate random combinations of parameters for outfitCountFolds testing."""
-	parameterSets: Dict[str, List[Any]] = {
+	parameterSets: dict[str, list[Any]] = {
 		'computationDivisions': [
 			None,
 			'maximum',
@@ -112,7 +116,7 @@ def parameterIterator() -> Callable[[List[int]], Generator[Dict[str, Any], None,
 		]
 	}
 
-	def makeParametersDynamic(listDimensions: List[int]) -> Dict[str, List[Any]]:
+	def makeParametersDynamic(listDimensions: list[int]) -> dict[str, list[Any]]:
 		"""Add context-dependent parameter values."""
 		parametersDynamic = parameterSets.copy()
 		leavesTotal = getLeavesTotal(listDimensions)
@@ -137,7 +141,7 @@ def parameterIterator() -> Callable[[List[int]], Generator[Dict[str, Any], None,
 
 		return parametersDynamic
 
-	def generateCombinations(listDimensions: List[int]) -> Generator[Dict[str, Any], None, None]:
+	def generateCombinations(listDimensions: list[int]) -> Generator[dict[str, Any], None, None]:
 		parametersDynamic = makeParametersDynamic(listDimensions)
 		parameterKeys = list(parametersDynamic.keys())
 		parameterValues = [parametersDynamic[key] for key in parameterKeys]
@@ -152,7 +156,7 @@ def parameterIterator() -> Callable[[List[int]], Generator[Dict[str, Any], None,
 
 	return generateCombinations
 
-def test_saveFoldsTotal_fallback(pathTmpTesting: pathlib.Path) -> None:
+def test_saveFoldsTotal_fallback(pathTmpTesting: Path) -> None:
 	foldsTotal = 123
 	pathFilename = pathTmpTesting / "foldsTotal.txt"
 	with unittest.mock.patch("pathlib.Path.write_text", side_effect=OSError("Simulated write failure")):

tests/test_tasks.py

@@ -4,10 +4,10 @@ import pytest
 # TODO add a test. `C` = number of logical cores available. `n = C + 1`. Ensure that `[2,n]` is computed correctly.
 # Or, probably smarter: limit the number of cores, then run a test with C+1.
 
-def test_countFoldsComputationDivisionsInvalid(listDimensionsTestFunctionality: List[int]) -> None:
+def test_countFoldsComputationDivisionsInvalid(listDimensionsTestFunctionality: list[int]) -> None:
 	standardizedEqualTo(ValueError, countFolds, listDimensionsTestFunctionality, None, {"wrong": "value"})
 
-def test_countFoldsComputationDivisionsMaximum(listDimensionsTestParallelization: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]) -> None:
+def test_countFoldsComputationDivisionsMaximum(listDimensionsTestParallelization: list[int], foldsTotalKnown: dict[tuple[int, ...], int]) -> None:
 	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
 
 @pytest.mark.parametrize("nameOfTest,callablePytest", PytestFor_defineConcurrencyLimit())
@@ -15,7 +15,7 @@ def test_defineConcurrencyLimit(nameOfTest: str, callablePytest: Callable[[], No
 	callablePytest()
 
 @pytest.mark.parametrize("CPUlimitParameter", [{"invalid": True}, ["weird"]])
-def test_countFolds_cpuLimitOopsie(listDimensionsTestFunctionality: List[int], CPUlimitParameter: Dict[str, bool] | List[str]) -> None:
+def test_countFolds_cpuLimitOopsie(listDimensionsTestFunctionality: list[int], CPUlimitParameter: dict[str, bool] | list[str]) -> None:
 	standardizedEqualTo(ValueError, countFolds, listDimensionsTestFunctionality, None, 'cpu', CPUlimitParameter)
 
 @pytest.mark.parametrize("computationDivisions, concurrencyLimit, listDimensions, expectedTaskDivisions", [
@@ -25,7 +25,7 @@ def test_countFolds_cpuLimitOopsie(listDimensionsTestFunctionality: List[int], C
 	(["invalid"], 4, [19, 23], ValueError),
 	(20, 4, [3,5], ValueError)
 ])
-def test_getTaskDivisions(computationDivisions: None | List[str] | Literal['maximum'] | Literal['cpu'] | Literal[20], concurrencyLimit: Literal[4], listDimensions: List[int], expectedTaskDivisions: type[ValueError] | Literal[0] | Literal[77] | Literal[4]) -> None:
+def test_getTaskDivisions(computationDivisions: None | list[str] | Literal['maximum'] | Literal['cpu'] | Literal[20], concurrencyLimit: Literal[4], listDimensions: list[int], expectedTaskDivisions: type[ValueError] | Literal[0] | Literal[77] | Literal[4]) -> None:
 	standardizedEqualTo(expectedTaskDivisions, getTaskDivisions, computationDivisions, concurrencyLimit, None, listDimensions)
 
 @pytest.mark.parametrize("expected,parameter", [
@@ -35,6 +35,6 @@ def test_getTaskDivisions(computationDivisions: None | List[str] | Literal['maxi
 	(ValueError, {2}),  # set
 	(ValueError, {"cores": 2}),  # dict
 ])
-def test_setCPUlimitMalformedParameter(expected: type[ValueError] | Literal[2], parameter: List[int] | Tuple[int] | set[int] | Dict[str, int] | Literal['2']) -> None:
+def test_setCPUlimitMalformedParameter(expected: type[ValueError] | Literal[2], parameter: list[int] | tuple[int] | set[int] | dict[str, int] | Literal['2']) -> None:
 	"""Test that invalid CPUlimit types are properly handled."""
 	standardizedEqualTo(expected, setCPUlimit, parameter)

mapFolding/syntheticModules/numba_countInitialize.py

@@ -1,52 +0,0 @@
-from mapFolding import indexMy
-from mapFolding import indexTrack
-from numba import jit
-from numba import uint8
-from numpy import dtype
-from numpy import ndarray
-from numpy import integer
-from typing import Tuple
-from typing import Any
-
-@jit((uint8[:, :, ::1], uint8[::1], uint8[::1], uint8[:, ::1]), _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)
-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 my[indexMy.leaf1ndex.value]:
-        if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
-            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
-            while my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]:
-                if connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]:
-                    my[indexMy.dimensionsUnconstrained.value] -= 1
-                else:
-                    my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
-                    while my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]:
-                        gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.leafConnectee.value]
-                        if track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] == 0:
-                            my[indexMy.gap1ndexCeiling.value] += 1
-                        track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
-                        my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
-                my[indexMy.indexDimension.value] += 1
-            if not my[indexMy.dimensionsUnconstrained.value]:
-                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
-            my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
-            while my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]:
-                gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
-                if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsUnconstrained.value]:
-                    my[indexMy.gap1ndex.value] += 1
-                track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
-                my[indexMy.indexMiniGap.value] += 1
-        if my[indexMy.leaf1ndex.value]:
-            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
-        if my[indexMy.gap1ndex.value] > 0:
-            return

mapFolding/syntheticModules/numba_countParallel.py

@@ -1,65 +0,0 @@
-from mapFolding import indexMy
-from mapFolding import indexTrack
-from numba import prange
-from numba import int64
-from numba import jit
-from numba import uint8
-from numpy import dtype
-from numpy import ndarray
-from numpy import integer
-from typing import Tuple
-from typing import Any
-
-@jit((uint8[:, :, ::1], int64[::1], uint8[::1], uint8[::1], uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=True)
-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 prange(taskDivisionsPrange):
-        groupsOfFolds: int = 0
-        gapsWhere = gapsWherePARALLEL.copy()
-        my = myPARALLEL.copy()
-        track = trackPARALLEL.copy()
-        my[indexMy.taskIndex.value] = indexSherpa
-        while my[indexMy.leaf1ndex.value]:
-            if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
-                if my[indexMy.leaf1ndex.value] > foldGroups[-1]:
-                    groupsOfFolds += 1
-                else:
-                    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
-                    while my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]:
-                        if connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]] == my[indexMy.leaf1ndex.value]:
-                            my[indexMy.dimensionsUnconstrained.value] -= 1
-                        else:
-                            my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], my[indexMy.leaf1ndex.value]]
-                            while my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]:
-                                if my[indexMy.leaf1ndex.value] != my[indexMy.taskDivisions.value] or my[indexMy.leafConnectee.value] % my[indexMy.taskDivisions.value] == my[indexMy.taskIndex.value]:
-                                    gapsWhere[my[indexMy.gap1ndexCeiling.value]] = my[indexMy.leafConnectee.value]
-                                    if track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] == 0:
-                                        my[indexMy.gap1ndexCeiling.value] += 1
-                                    track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
-                                my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
-                        my[indexMy.indexDimension.value] += 1
-                    my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
-                    while my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]:
-                        gapsWhere[my[indexMy.gap1ndex.value]] = gapsWhere[my[indexMy.indexMiniGap.value]]
-                        if track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] == my[indexMy.dimensionsUnconstrained.value]:
-                            my[indexMy.gap1ndex.value] += 1
-                        track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
-                        my[indexMy.indexMiniGap.value] += 1
-            while my[indexMy.leaf1ndex.value] and my[indexMy.gap1ndex.value] == track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]:
-                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]]
-            if my[indexMy.leaf1ndex.value]:
-                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
-        foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds

mapFolding/syntheticModules/numba_countSequential.py

@@ -1,67 +0,0 @@
-from mapFolding import indexMy
-from mapFolding import indexTrack
-from numba import int64
-from numba import jit
-from numba import uint8
-from numpy import dtype
-from numpy import ndarray
-from numpy import integer
-from typing import Tuple
-from typing import Any
-
-@jit((uint8[:, :, ::1], int64[::1], uint8[::1], uint8[::1], uint8[:, ::1]), _nrt=True, boundscheck=False, cache=True, error_model='numpy', fastmath=True, forceinline=True, inline='always', looplift=False, no_cfunc_wrapper=True, no_cpython_wrapper=True, nopython=True, parallel=False)
-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:
-    leafBelow = track[indexTrack.leafBelow.value]
-    gapRangeStart = track[indexTrack.gapRangeStart.value]
-    countDimensionsGapped = track[indexTrack.countDimensionsGapped.value]
-    leafAbove = track[indexTrack.leafAbove.value]
-    leaf1ndex = my[indexMy.leaf1ndex.value]
-    dimensionsUnconstrained = my[indexMy.dimensionsUnconstrained.value]
-    dimensionsTotal = my[indexMy.dimensionsTotal.value]
-    gap1ndexCeiling = my[indexMy.gap1ndexCeiling.value]
-    indexDimension = my[indexMy.indexDimension.value]
-    leafConnectee = my[indexMy.leafConnectee.value]
-    indexMiniGap = my[indexMy.indexMiniGap.value]
-    gap1ndex = my[indexMy.gap1ndex.value]
-    taskIndex = my[indexMy.taskIndex.value]
-    groupsOfFolds: int = 0
-    while leaf1ndex:
-        if leaf1ndex <= 1 or leafBelow[0] == 1:
-            if leaf1ndex > foldGroups[-1]:
-                groupsOfFolds += 1
-            else:
-                dimensionsUnconstrained = dimensionsTotal
-                gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
-                indexDimension = 0
-                while indexDimension < dimensionsTotal:
-                    leafConnectee = connectionGraph[indexDimension, leaf1ndex, leaf1ndex]
-                    if leafConnectee == leaf1ndex:
-                        dimensionsUnconstrained -= 1
-                    else:
-                        while leafConnectee != leaf1ndex:
-                            gapsWhere[gap1ndexCeiling] = leafConnectee
-                            if countDimensionsGapped[leafConnectee] == 0:
-                                gap1ndexCeiling += 1
-                            countDimensionsGapped[leafConnectee] += 1
-                            leafConnectee = connectionGraph[indexDimension, leaf1ndex, leafBelow[leafConnectee]]
-                    indexDimension += 1
-                indexMiniGap = gap1ndex
-                while indexMiniGap < gap1ndexCeiling:
-                    gapsWhere[gap1ndex] = gapsWhere[indexMiniGap]
-                    if countDimensionsGapped[gapsWhere[indexMiniGap]] == dimensionsUnconstrained:
-                        gap1ndex += 1
-                    countDimensionsGapped[gapsWhere[indexMiniGap]] = 0
-                    indexMiniGap += 1
-        while leaf1ndex and gap1ndex == gapRangeStart[leaf1ndex - 1]:
-            leaf1ndex -= 1
-            leafBelow[leafAbove[leaf1ndex]] = leafBelow[leaf1ndex]
-            leafAbove[leafBelow[leaf1ndex]] = leafAbove[leaf1ndex]
-        if leaf1ndex:
-            gap1ndex -= 1
-            leafAbove[leaf1ndex] = gapsWhere[gap1ndex]
-            leafBelow[leaf1ndex] = leafBelow[leafAbove[leaf1ndex]]
-            leafBelow[leafAbove[leaf1ndex]] = leaf1ndex
-            leafAbove[leafBelow[leaf1ndex]] = leaf1ndex
-            gapRangeStart[leaf1ndex] = gap1ndex
-            leaf1ndex += 1
-    foldGroups[taskIndex] = groupsOfFolds

mapFolding/theSSOTnumba.py

@@ -1,125 +0,0 @@
-"""I have so much truth, I need two files to contain it all!"""
-"""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**				  |
-| ----------------------- | --------------------------------------------------- | --------------------- | --------------- | ------------------------ |
-| `no_rewrites`		   | Disable AST rewrites optimization				   | Debugging			 |				 |						  |
-| `error_model`		   | Divide by zero: kill or chill?					  | Error checking		| ?			   |						  |
-| `_nrt`				  | Enable No Runtime type checking					 | Startup speed		 | Smaller		 | No type protection	   |
-| `forceinline`		   | Force function inlining							 | Reduce function calls | Likely larger   |						  |
-| `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."
-"""
-
-parametersNumbaMinimum: Final[ParametersNumba] = {
-	'_nrt': True,
-	'boundscheck': True,
-	'cache': True,
-	'error_model': 'numpy',
-	'fastmath': True,
-	'forceinline': False,
-	'inline': 'always',
-	'looplift': False,
-	'no_cfunc_wrapper': False,
-	'no_cpython_wrapper': False,
-	'nopython': False,
-	'forceobj': True,
-	'parallel': False,
-}

mapFolding-0.4.2.dist-info/RECORD

@@ -1,42 +0,0 @@
-mapFolding/__init__.py,sha256=_YjoypHXmWLmEWwhFVgKO83Uf28ksesT9F73oJoAIPE,1323
-mapFolding/basecamp.py,sha256=v0VCF_Zgm_XBHcz4bqblsxfHwAxZKgenW6um77quWLk,3751
-mapFolding/beDRY.py,sha256=ejl-eIZTqAHCBNIND0pP_F9BxkPEWIlVXbCTk2Ki8x8,15751
-mapFolding/oeis.py,sha256=3hv71o8bhckjY0nsSY5JTJ2LrpJcuhZ9j3mP6LWLIQc,11124
-mapFolding/theDao.py,sha256=vyln6gXdRp87Xhtuy31bjCpMv_8vL4KH6s1fH40V9oA,12832
-mapFolding/theSSOT.py,sha256=QrEMPREjEbt1H8HcrM2Nm_hv7JsFWRG3lHdUU0Jrv-w,10238
-mapFolding/theSSOTnumba.py,sha256=5jTbJyu9XASYC4eIoUj98eVKWdWyjZw-XF3V2GK8cLg,4445
-mapFolding/reference/flattened.py,sha256=S6D9wiFTlbeoetEqaMLOcA-R22BHOzjqPRujffNxxUM,14875
-mapFolding/reference/hunterNumba.py,sha256=jDS0ORHkIhcJ1rzA5hT49sZHKf3rgJOoGesUCcbKFFY,6054
-mapFolding/reference/irvineJavaPort.py,sha256=7GvBU0tnS6wpFgkYad3465do9jBQW-2bYvbCYyABPHM,3341
-mapFolding/reference/jax.py,sha256=7ji9YWia6Kof0cjcNdiS1GG1rMbC5SBjcyVr_07AeUk,13845
-mapFolding/reference/lunnan.py,sha256=iAbJELfW6RKNMdPcBY9b6rGQ-z1zoRf-1XCurCRMOo8,3951
-mapFolding/reference/lunnanNumpy.py,sha256=rwVP3WIDXimpAuaxhRIuBYU56nVDTKlfGiclw_FkgUU,3765
-mapFolding/reference/lunnanWhile.py,sha256=uRrMT23jTJvoQDlD_FzeIQe_pfMXJG6_bRvs7uhC8z0,3271
-mapFolding/reference/rotatedEntryPoint.py,sha256=USZY3n3zwhSE68ATscUuN66t1qShuEbMI790Gz9JFTw,9352
-mapFolding/reference/total_countPlus1vsPlusN.py,sha256=wpgay-uqPOBd64Z4Pg6tg40j7-4pzWHGMM6v0bnmjhE,6288
-mapFolding/someAssemblyRequired/__init__.py,sha256=wtec_hIz-AKz0_hGdXsWnCKTcCxdMV9-WK6SiIriAeU,396
-mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=nX8tghZClYt7zJd6RpZBXhE_h-CGRHOS17biqiEdf-o,855
-mapFolding/someAssemblyRequired/makeJob.py,sha256=c9sTRUK90snTCcXCvs86VKBH6z_nt3OVFjNs_WgCoIg,2422
-mapFolding/someAssemblyRequired/synthesizeModuleJAX.py,sha256=jatvtYhK5ZJK-YmCKATt7w3icFXXO79cZDAYVrU9bgA,1258
-mapFolding/someAssemblyRequired/synthesizeNumba.py,sha256=3JF1FZwSB-dhLUM_pMy11dI4x1dnWOFQSfJytZHYl0M,17351
-mapFolding/someAssemblyRequired/synthesizeNumbaGeneralized.py,sha256=k8IaCT74ZPhHyra0MbCRdt_5k0Ov3vJgXlN5tbLVnf4,13998
-mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=2sKZgc5kyyz2KaoApcazj_37UgBqAkxORFeROWWU5tk,9038
-mapFolding/someAssemblyRequired/synthesizeNumbaModules.py,sha256=_iRXjMASB_BnYJeH8Rt7FlC-GE7lkZ1Hy292XTaUCu4,3785
-mapFolding/syntheticModules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mapFolding/syntheticModules/numba_countInitialize.py,sha256=9u-Skda9ntDxo_CiD5T4lUU1-Ts5GDZ33zs_Ybf77-Q,4274
-mapFolding/syntheticModules/numba_countParallel.py,sha256=96-TDwLJgZhR9tFm2bqVDpk8TuWPx_2qFH7oNV78yUI,5517
-mapFolding/syntheticModules/numba_countSequential.py,sha256=WCcPYnkyNpZS7SRMvx1A-IMIAFP5iHL9u9sj9gR8Yhw,3688
-mapFolding/syntheticModules/numba_doTheNeedful.py,sha256=zBXDEN4DJTpCu_ho314-MWdS_08kP_vAgV-8sJDVgvo,1368
-tests/__init__.py,sha256=eg9smg-6VblOr0kisM40CpGnuDtU2JgEEWGDTFVOlW8,57
-tests/conftest.py,sha256=vH1BSOs8G6nIPWKFkSQFmX031IZqNFC4oiEia74mkHU,10554
-tests/test_computations.py,sha256=qBha4IggMfr6ZH06W3M66enTA6PWsx8vkDp5eqYFM9M,4765
-tests/test_oeis.py,sha256=31kdO1vnu2Lon43vM-YJVS4g40Ic03DWNER-cJcpxX4,4916
-tests/test_other.py,sha256=u0vINT5EyVsXTNTR2DZIMpWCg4FH471jjHLRzC2JX7U,8351
-tests/test_tasks.py,sha256=iq6_dh43JQkC2vAWXua0Xe915BKFGbvRJAkmbco854A,2389
-tests/test_types.py,sha256=58tmPG9WOeGGAQbdQK_h_7t4SnENnZugH4WXlI8-L-M,171
-mapFolding-0.4.2.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-mapFolding-0.4.2.dist-info/METADATA,sha256=EPivaT4-_Ygz9_DobQKBIigNnDkWtUq7vm6hJtYiDeQ,7633
-mapFolding-0.4.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.4.2.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.4.2.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapFolding-0.4.2.dist-info/RECORD,,

tests/test_types.py

@@ -1,5 +0,0 @@
-"""Type checking tests for mapFolding package."""
-
-def test_static_typing() -> None:
-	"""This is a placeholder. pytest-mypy will run type checking automatically."""
-	pass