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

mapFolding/theSSOT.py

@@ -1,12 +1,8 @@
-from collections import defaultdict
-from mapFolding.theSSOTnumba import *
+from mapFolding.theSSOTdatatypes import *
+from numba.core.compiler import CompilerBase as numbaCompilerBase
 from numpy import dtype, integer, ndarray
 from types import ModuleType
-from typing import Any, Callable, cast, Dict, Final, Optional, Tuple, Type, TYPE_CHECKING
-import enum
-import numba
-import numpy
-import numpy.typing
+from typing import Any, Callable, Dict, Final, Tuple, TYPE_CHECKING, Union, cast
 import pathlib
 import sys
 
@@ -20,45 +16,22 @@ if TYPE_CHECKING:
 else:
 	TypedDict = dict
 
-"""I have hobbled together:
-TypedDict, Enum, defaultdict, and lookup dictionaries to make DIY immutability and delayed realization/instantiation.
-Nevertheless, I am both confident that all of these processes will be replaced and completely ignorant of what will replace them."""
-
 """Technical concepts I am likely using and likely want to use more effectively:
 - Configuration Registry
 - Write-Once, Read-Many (WORM) / Immutable Initialization
 - Lazy Initialization
-- Separation of Concerns: in the sense that configuration is separated from business logic
-
-Furthermore, I want to more clearly divorce the concept of a single _source_ of (a) truth from
-the _authority_ of that truth. The analogy to a registry of ownership is still apt: the registry
-is, at most, a single (or centralized) source of truth, but it is merely the place to register/record
-the truth determined by some other authority.
+- Separation of configuration from business logic
 
-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.
+delay realization/instantiation until a concrete value is desired
+moment of truth: when the value is needed, not when the value is defined
 """
 
-"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}"
+# TODO I'm not sure if this is the right tool for the job.
+formatFilenameModuleDEFAULT = "numba_{callableTarget}.py"
+dispatcherCallableNameDEFAULT = "doTheNeedful"
 
 def getPathPackage() -> pathlib.Path:
 	import importlib, inspect
@@ -99,159 +72,6 @@ class computationState(TypedDict):
 	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
-
-	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()
-
-_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`.")
-
 _datatypeModuleScalar = 'numba'
 _decoratorCallable = 'jit'
 def Z0Z_getDatatypeModuleScalar() -> str:
@@ -277,3 +97,44 @@ class FREAKOUT(Exception):
 # TODO Learn how to assign theDao.py the power to set this truth
 # while using theSSOT.py as the SSOT.
 Z0Z_identifierCountFolds = 'groupsOfFolds'
+
+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[Type[numbaCompilerBase]]
+	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."""
+
+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/theSSOTdatatypes.py

@@ -0,0 +1,168 @@
+from collections import defaultdict
+from typing import Any, cast, Dict, Final, Optional, Type, TYPE_CHECKING
+import enum
+import sys
+import numba
+import numpy
+
+try:
+	from typing import NotRequired
+except ImportError:
+	from typing_extensions import NotRequired
+
+if TYPE_CHECKING:
+	from typing import TypedDict
+else:
+	TypedDict = dict
+
+@enum.verify(enum.CONTINUOUS, enum.UNIQUE) if sys.version_info >= (3, 11) else lambda x: x
+class EnumIndices(enum.IntEnum):
+	@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()
+
+_datatypeDefault: Final[Dict[str, str]] = {
+	'elephino': 'uint16',
+	'foldsTotal': 'int64',
+	'leavesTotal': 'uint16',
+}
+_datatypeModule = ''
+_datatypeModuleDEFAULT: Final[str] = 'numpy'
+
+_datatype: Dict[str, str] = defaultdict(str)
+
+def reportDatatypeLimit(identifier: str, datatype: str, sourGrapes: Optional[bool] = False) -> str:
+	global _datatype
+	if not _datatype[identifier]:
+		_datatype[identifier] = datatype
+	elif _datatype[identifier] == datatype:
+		pass
+	elif sourGrapes:
+		raise Exception(f"Datatype is '{_datatype[identifier]}' not '{datatype}', so you can take your ball and go home.")
+	return _datatype[identifier]
+
+def setDatatypeModule(datatypeModule: str, sourGrapes: Optional[bool] = False) -> str:
+	global _datatypeModule
+	if not _datatypeModule:
+		_datatypeModule = datatypeModule
+	elif _datatypeModule == datatypeModule:
+		pass
+	elif sourGrapes:
+		raise Exception(f"Datatype module is '{_datatypeModule}' not '{datatypeModule}', so you can take your ball and go home.")
+	return _datatypeModule
+
+def setDatatypeElephino(datatype: str, sourGrapes: Optional[bool] = False) -> str:
+	return reportDatatypeLimit('elephino', datatype, sourGrapes)
+
+def setDatatypeFoldsTotal(datatype: str, sourGrapes: Optional[bool] = False) -> str:
+	return reportDatatypeLimit('foldsTotal', datatype, sourGrapes)
+
+def setDatatypeLeavesTotal(datatype: str, sourGrapes: Optional[bool] = False) -> str:
+	return reportDatatypeLimit('leavesTotal', datatype, sourGrapes)
+
+def _get_datatype(identifier: str) -> str:
+	global _datatype
+	if not _datatype[identifier]:
+		if identifier in indexMy._member_names_:
+			_datatype[identifier] = _datatypeDefault.get(identifier) or _get_datatype('elephino')
+		elif identifier in indexTrack._member_names_:
+			_datatype[identifier] = _datatypeDefault.get(identifier) or _get_datatype('elephino')
+		else:
+			_datatype[identifier] = _datatypeDefault.get(identifier) or _get_datatype('foldsTotal')
+	return _datatype[identifier]
+
+def getDatatypeModule() -> str:
+	global _datatypeModule
+	if not _datatypeModule:
+		_datatypeModule = _datatypeModuleDEFAULT
+	return _datatypeModule
+
+def setInStone(identifier: str) -> Type[Any]:
+	datatypeModule = getDatatypeModule()
+	datatypeStr = _get_datatype(identifier)
+	return cast(Type[Any], getattr(eval(datatypeModule), datatypeStr))
+
+def hackSSOTdtype(identifier: str) -> Type[Any]:
+	_hackSSOTdtype={
+	'connectionGraph': 	'dtypeLeavesTotal',
+	'dtypeElephino': 	'dtypeElephino',
+	'dtypeFoldsTotal': 	'dtypeFoldsTotal',
+	'dtypeLeavesTotal': 'dtypeLeavesTotal',
+	'foldGroups': 		'dtypeFoldsTotal',
+	'gapsWhere': 		'dtypeLeavesTotal',
+	'mapShape': 		'dtypeLeavesTotal',
+	'my': 				'dtypeElephino',
+	'track': 			'dtypeElephino',
+	}
+	RubeGoldBerg = _hackSSOTdtype[identifier]
+	if RubeGoldBerg == 'dtypeElephino':
+		return setInStone('elephino')
+	elif RubeGoldBerg == 'dtypeFoldsTotal':
+		return setInStone('foldsTotal')
+	elif RubeGoldBerg == 'dtypeLeavesTotal':
+		return setInStone('leavesTotal')
+	raise Exception("Dude, you forgot to set a value in `hackSSOTdtype`.")
+
+def hackSSOTdatatype(identifier: str) -> str:
+	_hackSSOTdatatype={
+	'connectionGraph':	 		'datatypeLeavesTotal',
+	'countDimensionsGapped': 	'datatypeLeavesTotal',
+	'datatypeElephino': 		'datatypeElephino',
+	'datatypeFoldsTotal': 		'datatypeFoldsTotal',
+	'datatypeLeavesTotal': 		'datatypeLeavesTotal',
+	'dimensionsTotal': 			'datatypeLeavesTotal',
+	'dimensionsUnconstrained':	'datatypeLeavesTotal',
+	'foldGroups': 				'datatypeFoldsTotal',
+	'gap1ndex': 				'datatypeLeavesTotal',
+	'gap1ndexCeiling': 			'datatypeElephino',
+	'gapRangeStart': 			'datatypeElephino',
+	'gapsWhere': 				'datatypeLeavesTotal',
+	'groupsOfFolds': 			'datatypeFoldsTotal',
+	'indexDimension': 			'datatypeLeavesTotal',
+	'indexLeaf': 				'datatypeLeavesTotal',
+	'indexMiniGap': 			'datatypeElephino',
+	'leaf1ndex': 				'datatypeLeavesTotal',
+	'leafAbove': 				'datatypeLeavesTotal',
+	'leafBelow': 				'datatypeLeavesTotal',
+	'leafConnectee': 			'datatypeLeavesTotal',
+	'mapShape': 				'datatypeLeavesTotal',
+	'my':	 					'datatypeElephino',
+	'taskDivisions': 			'datatypeLeavesTotal',
+	'taskIndex': 				'datatypeLeavesTotal',
+	'track':	 				'datatypeElephino',
+	}
+	RubeGoldBerg = _hackSSOTdatatype[identifier]
+	if RubeGoldBerg == 'datatypeElephino':
+		return _get_datatype('elephino')
+	elif RubeGoldBerg == 'datatypeFoldsTotal':
+		return _get_datatype('foldsTotal')
+	elif RubeGoldBerg == 'datatypeLeavesTotal':
+		return _get_datatype('leavesTotal')
+	raise Exception("Dude, you forgot to set a value in `hackSSOTdatatype`.")

{mapFolding-0.4.1.dist-info → mapFolding-0.4.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.4.1
+Version: 0.4.3
 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

mapFolding-0.4.3.dist-info/RECORD

@@ -0,0 +1,40 @@
+mapFolding/__init__.py,sha256=1-iO5PCGKlW81fhMDjSLrsKxuSeV-UMcU1NlKW352FM,1347
+mapFolding/basecamp.py,sha256=MyrkAbJZawW6CPVEJ_7iPfCYjngdFHmicSs8Ylq5S1E,3787
+mapFolding/beDRY.py,sha256=tDLddJzQoGvbcttJro8ML2B59KspMkZwIeZdm4hOy_4,16785
+mapFolding/oeis.py,sha256=8c6q3STjgp-c4Reode9PLLYS3c00wCsJW-yfte7NI60,11103
+mapFolding/theDao.py,sha256=PZgx_0X7QfdIpLpEO5mbdVNFMCRuP8PD-f62xU7C4U0,12618
+mapFolding/theSSOT.py,sha256=RQmSsjmysc9izjGLsVseZ0J0nDzG_rKY7QkrOF-47SU,5794
+mapFolding/theSSOTdatatypes.py,sha256=H0d1vAn59VCRPMhn28PtlBEZnjmQjEKofiefgvpBFsg,5955
+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=eJRZ8ttfaONMq-s3BawswJrHu_m0DUHp4dGpx6uVpuk,16920
+mapFolding/someAssemblyRequired/synthesizeNumbaGeneralized.py,sha256=3FiD6fDGzam6uvgTg7YEsGlLftbBOol2ajvEa4GNTec,16698
+mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=pknX6CeH9iuDTs9tp0gz33T2U5gjO8NMpPnQnnBU2gA,9138
+mapFolding/someAssemblyRequired/synthesizeNumbaModules.py,sha256=V9xpM1r4MQlhXoKLkF2PTg69gid7Ec64pbMc2ZZ2xXo,5590
+mapFolding/syntheticModules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/syntheticModules/numbaCount.py,sha256=VkTHk97gIBRZg7FwX7hCgfunSBK2Gyr4pp3fzHNrLhw,12907
+mapFolding/syntheticModules/numba_doTheNeedful.py,sha256=9syuZEc1KwH3BFp2TmK7-pBuT2N4lVJTiUhqu7ahaKY,1157
+tests/__init__.py,sha256=eg9smg-6VblOr0kisM40CpGnuDtU2JgEEWGDTFVOlW8,57
+tests/conftest.py,sha256=qP-ZCyyqXC4E9W_psMVbHPlXE-8Ue01fBckGqhzlhGQ,11972
+tests/test_computations.py,sha256=WO28l9AmrFY6kbcx9iJr6YNoqLbZ8Lgs7FryH5DG0BI,2856
+tests/test_oeis.py,sha256=C2F6XrI5oRPjc29lykN3e83rIcgl01UwBLB6L-Qz2pE,4733
+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.3.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapFolding-0.4.3.dist-info/METADATA,sha256=52v3PWTTXMbJwXFaUQFAnJilfn29HFiESW83sPFUL1M,7633
+mapFolding-0.4.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.4.3.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.4.3.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapFolding-0.4.3.dist-info/RECORD,,

tests/conftest.py

@@ -6,11 +6,11 @@ from mapFolding import *
 from mapFolding import basecamp, getAlgorithmDispatcher, getDispatcherCallable
 from mapFolding.beDRY import *
 from mapFolding.someAssemblyRequired import *
-from mapFolding.oeis import _getFilenameOEISbFile, _getOEISidInformation, _getOEISidValues
 from mapFolding.oeis import *
 from types import ModuleType
 from typing import Any, Callable, ContextManager, Dict, Generator, List, Literal, NoReturn, Optional, Sequence, Set, Tuple, Type, Union
 from Z0Z_tools.pytestForYourUse import PytestFor_defineConcurrencyLimit, PytestFor_intInnit, PytestFor_oopsieKwargsie
+import importlib.util
 import pathlib
 import pytest
 import random
@@ -101,36 +101,6 @@ def makeDictionaryFoldsTotalKnown() -> Dict[Tuple[int,...], int]:
 			dimensions = settings['getMapShape'](n)
 			dimensions.sort()
 			dictionaryMapDimensionsToFoldsTotalKnown[tuple(dimensions)] = foldingsTotal
-
-	# Are we in a place that has jobs?
-	pathJobDEFAULT = getPathJobRootDEFAULT()
-	if pathJobDEFAULT.exists():
-		# Are there foldsTotal files?
-		for pathFilenameFoldsTotal in pathJobDEFAULT.rglob('*.foldsTotal'):
-			if pathFilenameFoldsTotal.is_file():
-				try:
-					listDimensions = eval(pathFilenameFoldsTotal.stem)
-				except Exception:
-					continue
-				# Are the dimensions in the dictionary?
-				if isinstance(listDimensions, list) and all(isinstance(dimension, int) for dimension in listDimensions):
-					listDimensions.sort()
-					if tuple(listDimensions) in dictionaryMapDimensionsToFoldsTotalKnown:
-						continue
-					# Are the contents a reasonably large integer?
-					try:
-						foldsTotal = pathFilenameFoldsTotal.read_text()
-					except Exception:
-						continue
-					# Why did I sincerely believe this would only be three lines of code?
-					if foldsTotal.isdigit():
-						foldsTotalInteger = int(foldsTotal)
-						if foldsTotalInteger > 85109616 * 10**3:
-							# You made it this far, so fuck it: put it in the dictionary
-							dictionaryMapDimensionsToFoldsTotalKnown[tuple(listDimensions)] = foldsTotalInteger
-						dictionaryMapDimensionsToFoldsTotalKnown[tuple(listDimensions)] = foldsTotalInteger
-					# The sunk-costs fallacy claims another victim!
-
 	return dictionaryMapDimensionsToFoldsTotalKnown
 
 """
@@ -255,6 +225,35 @@ def useAlgorithmSourceDispatcher(useThisDispatcher: Callable) -> Generator[None,
 	useThisDispatcher(getAlgorithmDispatcher())
 	yield
 
+@pytest.fixture
+def syntheticDispatcherFixture(useThisDispatcher):
+	listCallablesInlineHARDCODED: List[str] = ['countInitialize', 'countParallel', 'countSequential']
+	listCallablesInline = listCallablesInlineHARDCODED
+	callableDispatcher = True
+	algorithmSource = None
+	relativePathWrite = None
+	filenameModuleWrite = 'pytestCount.py'
+	formatFilenameWrite = "pytest_{callableTarget}.py"
+	listSynthesizedModules: List[youOughtaKnow] = makeFlowNumbaOptimized(listCallablesInline, callableDispatcher, algorithmSource, relativePathWrite, filenameModuleWrite, formatFilenameWrite)
+	dispatcherSynthetic = youOughtaKnow('','','')
+	for stuff in listSynthesizedModules:
+		registrarRecordsTmpObject(stuff.pathFilenameForMe)
+		if stuff.callableSynthesized not in listCallablesInline:
+			dispatcherSynthetic: youOughtaKnow = stuff
+
+	dispatcherSpec = importlib.util.spec_from_file_location(dispatcherSynthetic.callableSynthesized, dispatcherSynthetic.pathFilenameForMe)
+	if dispatcherSpec is None:
+		raise ImportError(f"{dispatcherSynthetic.pathFilenameForMe=}")
+	if dispatcherSpec.loader is None:
+		raise ImportError(f"Failed to get loader for module {dispatcherSynthetic.pathFilenameForMe}")
+
+	dispatcherModule = importlib.util.module_from_spec(dispatcherSpec)
+	dispatcherSpec.loader.exec_module(dispatcherModule)
+	callableDispatcherSynthetic = getattr(dispatcherModule, dispatcherSynthetic.callableSynthesized)
+
+	useThisDispatcher(callableDispatcherSynthetic)
+	return callableDispatcherSynthetic
+
 def uniformTestMessage(expected: Any, actual: Any, functionName: str, *arguments: Any) -> str:
 	"""Format assertion message for any test comparison."""
 	return (f"\nTesting: `{functionName}({', '.join(str(parameter) for parameter in arguments)})`\n"