mapFolding 0.3.12__py3-none-any.whl → 0.4.1__py3-none-any.whl

mapFolding/theSSOT.py

@@ -2,7 +2,7 @@ from collections import defaultdict
 from mapFolding.theSSOTnumba import *
 from numpy import dtype, integer, ndarray
 from types import ModuleType
-from typing import Any, Callable, Dict, Final, Optional, Tuple, Type, TYPE_CHECKING, cast
+from typing import Any, Callable, cast, Dict, Final, Optional, Tuple, Type, TYPE_CHECKING
 import enum
 import numba
 import numpy
@@ -11,14 +11,14 @@ import pathlib
 import sys
 
 try:
-    from typing import NotRequired
+	from typing import NotRequired
 except ImportError:
-    from typing_extensions import NotRequired
+	from typing_extensions import NotRequired
 
 if TYPE_CHECKING:
-    from typing import TypedDict
+	from typing import TypedDict
 else:
-    TypedDict = dict
+	TypedDict = dict
 
 """I have hobbled together:
 TypedDict, Enum, defaultdict, and lookup dictionaries to make DIY immutability and delayed realization/instantiation.
@@ -39,102 +39,104 @@ And, I almost certainly want to change the semiotics from "authority" (of truth)
 Here, "power" is a direct analogy to https://hunterthinks.com/opinion/a-hohfeldian-primer.
 """
 
+"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
+	"""
+
 myPackageNameIs = "mapFolding"
 
 moduleOfSyntheticModules = "syntheticModules"
+formatModuleNameDEFAULT = "numba_{callableTarget}"
 
 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
+	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
+	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
+	pathSyntheticModules = getPathPackage() / moduleOfSyntheticModules
+	return pathSyntheticModules
 
 def getAlgorithmSource() -> ModuleType:
-    from mapFolding import theDao
-    return theDao
+	from mapFolding import theDao
+	return theDao
 
-def getAlgorithmCallable() -> Callable[..., None]:
-    algorithmSource = getAlgorithmSource()
-    return cast(Callable[..., None], algorithmSource.doTheNeedful)
+def getAlgorithmDispatcher() -> Callable[..., None]:
+	algorithmSource = getAlgorithmSource()
+	return cast(Callable[..., None], algorithmSource.doTheNeedful) # 'doTheNeedful' is duplicated and there is not a SSOT for it
 
 def getDispatcherCallable() -> Callable[..., None]:
-    from mapFolding.syntheticModules import numba_doTheNeedful
-    return cast(Callable[..., None], numba_doTheNeedful.doTheNeedful)
+	from mapFolding.syntheticModules import numba_doTheNeedful
+	return cast(Callable[..., None], numba_doTheNeedful.doTheNeedful)
 
 # NOTE I want this _concept_, not necessarily this method, to be well implemented and usable everywhere: Python, Numba, Jax, CUDA, idc
 class computationState(TypedDict):
-    connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]]
-    foldGroups:      ndarray[Tuple[int]          , dtype[integer[Any]]]
-    gapsWhere:       ndarray[Tuple[int]          , dtype[integer[Any]]]
-    mapShape:        ndarray[Tuple[int]          , dtype[integer[Any]]]
-    my:              ndarray[Tuple[int]          , dtype[integer[Any]]]
-    track:           ndarray[Tuple[int, int]     , dtype[integer[Any]]]
+	connectionGraph:	ndarray[Tuple[int, int, int], dtype[integer[Any]]]
+	foldGroups:			ndarray[Tuple[int]			, dtype[integer[Any]]]
+	gapsWhere:			ndarray[Tuple[int]			, dtype[integer[Any]]]
+	mapShape:			ndarray[Tuple[int]			, dtype[integer[Any]]]
+	my:					ndarray[Tuple[int]			, dtype[integer[Any]]]
+	track:				ndarray[Tuple[int, int]		, dtype[integer[Any]]]
 
 @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
+	"""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
+	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()
+	"""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
-    """
+	"""Indices for state tracking array."""
+	leafAbove				= enum.auto()
+	leafBelow				= enum.auto()
+	countDimensionsGapped	= enum.auto()
+	gapRangeStart			= enum.auto()
 
 _datatypeDefault: Final[Dict[str, str]] = {
-    'elephino': 'uint8',
-    'foldsTotal': 'int64',
-    'leavesTotal': 'uint8',
+	'elephino': 'uint8',
+	'foldsTotal': 'int64',
+	'leavesTotal': 'uint8',
 }
 _datatypeModule = ''
 _datatypeModuleDEFAULT: Final[str] = 'numpy'
@@ -142,134 +144,136 @@ _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]
+	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
+	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)
+	return reportDatatypeLimit('elephino', datatype, sourGrapes)
 
 def setDatatypeFoldsTotal(datatype: str, sourGrapes: Optional[bool] = False) -> str:
-    return reportDatatypeLimit('foldsTotal', datatype, sourGrapes)
+	return reportDatatypeLimit('foldsTotal', datatype, sourGrapes)
 
 def setDatatypeLeavesTotal(datatype: str, sourGrapes: Optional[bool] = False) -> str:
-    return reportDatatypeLimit('leavesTotal', datatype, sourGrapes)
+	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]
+	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
+	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))
+	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`.")
+	_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`.")
+	_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`.")
 
 _datatypeModuleScalar = 'numba'
 _decoratorCallable = 'jit'
 def Z0Z_getDatatypeModuleScalar() -> str:
-    return _datatypeModuleScalar
+	return _datatypeModuleScalar
 
 def Z0Z_setDatatypeModuleScalar(moduleName: str) -> str:
-    global _datatypeModuleScalar
-    _datatypeModuleScalar = moduleName
-    return _datatypeModuleScalar
+	global _datatypeModuleScalar
+	_datatypeModuleScalar = moduleName
+	return _datatypeModuleScalar
 
 def Z0Z_getDecoratorCallable() -> str:
-    return _decoratorCallable
+	return _decoratorCallable
 
 def Z0Z_setDecoratorCallable(decoratorName: str) -> str:
-    global _decoratorCallable
-    _decoratorCallable = decoratorName
-    return _decoratorCallable
+	global _decoratorCallable
+	_decoratorCallable = decoratorName
+	return _decoratorCallable
 
 class FREAKOUT(Exception):
-    pass
+	pass
 
-# This identifier is declared in theDao.py. Two sources of truth is better than 900.
+# The following identifier is declared in theDao.py.
+# TODO Learn how to assign theDao.py the power to set this truth
+# while using theSSOT.py as the SSOT.
 Z0Z_identifierCountFolds = 'groupsOfFolds'

mapFolding/theSSOTnumba.py

@@ -4,113 +4,129 @@ from typing import Final, TYPE_CHECKING, Dict, Any, Union, Callable, Tuple, Any
 import numba
 import numba.core.compiler
 try:
-    from typing import NotRequired
+	from typing import NotRequired
 except ImportError:
-    from typing_extensions import NotRequired
+	from typing_extensions import NotRequired
 
 if TYPE_CHECKING:
-    from typing import TypedDict
+	from typing import TypedDict
 else:
-    TypedDict = dict
+	TypedDict = dict
 
 """
 Old notes that are not entirely accurate.
 
-| **Option**              | **Description**                                     | **Why**               | **Size**        | **But**                  |
+| **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             |
+| `_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			 |
 
 """
 # NOTE Deepseek removed forceinline=True, inline='always'
 # 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]
+	_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,
+	'_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,
+	'_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,
+	**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,
+	**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,
+	**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,
+}