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

mapFolding/someAssemblyRequired/synthesizeNumbaJob.py

@@ -1,7 +1,7 @@
 """Synthesize one file to compute `foldsTotal` of `mapShape`."""
 from mapFolding.someAssemblyRequired.synthesizeNumba import *
 
-def doUnrollCountGaps(FunctionDefTarget: ast.FunctionDef, stateJob: computationState, allImports: UniversalImportTracker) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+def doUnrollCountGaps(FunctionDefTarget: ast.FunctionDef, stateJob: computationState, allImports: UniversalImportTracker) -> tuple[ast.FunctionDef, UniversalImportTracker]:
 	"""The initial results were very bad."""
 	FunctionDefTarget = findAndReplaceWhileLoopIn_body(FunctionDefTarget, 'indexDimension', stateJob['my'][indexMy.dimensionsTotal])
 	FunctionDefTarget = removeAssignTargetFrom_body(FunctionDefTarget, 'indexDimension')
@@ -27,14 +27,7 @@ def doUnrollCountGaps(FunctionDefTarget: ast.FunctionDef, stateJob: computationS
 		FunctionDefTarget = transformer.visit(FunctionDefTarget)
 	return FunctionDefTarget, allImports
 
-def writeJobNumba(mapShape: Sequence[int]
-				, algorithmSource: ModuleType
-				, callableTarget: Optional[str] = None
-				, parametersNumba: Optional[ParametersNumba] = None
-				, pathFilenameWriteJob: Optional[Union[str, os.PathLike[str]]] = None
-				, unrollCountGaps: Optional[bool] = False
-				, **keywordArguments: Optional[Any]
-				) -> pathlib.Path:
+def writeJobNumba(mapShape: Sequence[int], algorithmSource: ModuleType, callableTarget: str | None = None, parametersNumba: ParametersNumba | None = None, pathFilenameWriteJob: str | PathLike[str] | None = None, unrollCountGaps: bool | None = False, **keywordArguments: Any | None) -> Path:
 	""" Parameters: **keywordArguments: most especially for `computationDivisions` if you want to make a parallel job. Also `CPUlimit`. """
 
 	""" Notes:
@@ -122,7 +115,7 @@ def writeJobNumba(mapShape: Sequence[int]
 
 	# NOTE add imports, make str, remove unused imports
 	astImports = allImports.makeListAst()
-	astModule = ast.Module(body=cast(List[ast.stmt], astImports + [FunctionDefTarget] + [astLauncher]), type_ignores=[])
+	astModule = ast.Module(body=cast(list[ast.stmt], astImports + [FunctionDefTarget] + [astLauncher]), type_ignores=[])
 	ast.fix_missing_locations(astModule)
 	pythonSource = ast.unparse(astModule)
 	pythonSource = autoflake.fix_code(pythonSource, ['mapFolding', 'numba', 'numpy'])
@@ -132,9 +125,9 @@ def writeJobNumba(mapShape: Sequence[int]
 	if pathFilenameWriteJob is None:
 		filename = getFilenameFoldsTotal(stateJob['mapShape'])
 		pathRoot = getPathJobRootDEFAULT()
-		pathFilenameWriteJob = pathlib.Path(pathRoot, pathlib.Path(filename).stem, pathlib.Path(filename).with_suffix('.py'))
+		pathFilenameWriteJob = Path(pathRoot, Path(filename).stem, Path(filename).with_suffix('.py'))
 	else:
-		pathFilenameWriteJob = pathlib.Path(pathFilenameWriteJob)
+		pathFilenameWriteJob = Path(pathFilenameWriteJob)
 	pathFilenameWriteJob.parent.mkdir(parents=True, exist_ok=True)
 
 	pathFilenameWriteJob.write_text(pythonSource)
@@ -142,7 +135,7 @@ def writeJobNumba(mapShape: Sequence[int]
 	return pathFilenameWriteJob
 
 if __name__ == '__main__':
-	mapShape = [5,5]
+	mapShape: list[int] = [5,5]
 	from mapFolding.syntheticModules import numbaCount
 	algorithmSource: ModuleType = numbaCount
 

mapFolding/someAssemblyRequired/synthesizeNumbaModules.py

@@ -4,21 +4,21 @@ everything I am doing. I would rather benefit from humanity's
 collective wisdom."""
 from mapFolding.someAssemblyRequired.synthesizeNumba import *
 
-def getFunctionDef(algorithmSource: ModuleType, *arguments, **keywordArguments) -> Tuple[ast.FunctionDef, UniversalImportTracker]:
+def getFunctionDef(algorithmSource: ModuleType, *arguments, **keywordArguments) -> tuple[ast.FunctionDef, UniversalImportTracker]:
 	pythonSource = inspect.getsource(algorithmSource)
 	astModule: ast.Module = ast.parse(pythonSource, type_comments=True)
 	FunctionDefTarget, allImports = makeFunctionDef(astModule, *arguments, **keywordArguments)
 	return FunctionDefTarget, allImports
 
-def makePythonSource(listFunctionDefs: List[ast.FunctionDef], listAstImports: List[ast.Import|ast.ImportFrom], additional_imports: List[str]) -> str:
-	astModule = ast.Module(body=cast(List[ast.stmt], listAstImports + listFunctionDefs), type_ignores=[])
+def makePythonSource(listFunctionDefs: list[ast.FunctionDef], listAstImports: list[ast.Import | ast.ImportFrom], additional_imports: list[str]) -> str:
+	astModule = ast.Module(body=cast(list[ast.stmt], listAstImports + listFunctionDefs), type_ignores=[])
 	ast.fix_missing_locations(astModule)
 	pythonSource = ast.unparse(astModule)
 	if not pythonSource: raise FREAKOUT
 	pythonSource = autoflake.fix_code(pythonSource, additional_imports)
 	return pythonSource
 
-def writePythonAsModule(pythonSource: str, listCallableSynthesized: List[str], relativePathWrite: Optional[pathlib.Path], filenameWrite: Optional[str], formatFilenameWrite: Optional[str]) -> List[youOughtaKnow]:
+def writePythonAsModule(pythonSource: str, listCallableSynthesized: list[str], relativePathWrite: Path | None, filenameWrite: str | None, formatFilenameWrite: str | None) -> list[youOughtaKnow]:
 	pathFilename = None
 	if not relativePathWrite:
 		pathWrite = getPathSyntheticModules()
@@ -46,7 +46,7 @@ def writePythonAsModule(pythonSource: str, listCallableSynthesized: List[str], r
 	dumbassPythonNamespace = pathFilename.relative_to(howIsThisStillAThing).with_suffix('').parts
 	ImaModule = '.'.join(dumbassPythonNamespace)
 
-	listStuffYouOughtaKnow: List[youOughtaKnow] = []
+	listStuffYouOughtaKnow: list[youOughtaKnow] = []
 
 	for callableTarget in listCallableSynthesized:
 		astImportFrom = ast.ImportFrom(module=ImaModule, names=[ast.alias(name=callableTarget, asname=None)], level=0)
@@ -55,13 +55,7 @@ def writePythonAsModule(pythonSource: str, listCallableSynthesized: List[str], r
 
 	return listStuffYouOughtaKnow
 
-def makeFlowNumbaOptimized(listCallablesInline: List[str]
-							, callableDispatcher: Optional[bool] = False
-							, algorithmSource: Optional[ModuleType] = None
-							, relativePathWrite: Optional[pathlib.Path] = None
-							, filenameModuleWrite: Optional[str] = None
-							, formatFilenameWrite: Optional[str] = None
-							) -> List[youOughtaKnow]:
+def makeFlowNumbaOptimized(listCallablesInline: list[str], callableDispatcher: bool | None = False, algorithmSource: ModuleType | None = None, relativePathWrite: Path | None = None, filenameModuleWrite: str | None = None, formatFilenameWrite: str | None = None) -> list[youOughtaKnow]:
 	if relativePathWrite and relativePathWrite.is_absolute():
 		raise ValueError("The path to write the module must be relative to the root of the package.")
 	if not algorithmSource:
@@ -69,10 +63,10 @@ def makeFlowNumbaOptimized(listCallablesInline: List[str]
 
 	Z0Z_filenameModuleWrite = 'numbaCount.py'
 
-	listStuffYouOughtaKnow: List[youOughtaKnow] = []
+	listStuffYouOughtaKnow: list[youOughtaKnow] = []
 	additional_imports = ['mapFolding', 'numba', 'numpy']
 
-	listFunctionDefs: List[ast.FunctionDef] = []
+	listFunctionDefs: list[ast.FunctionDef] = []
 	allImportsModule = UniversalImportTracker()
 	for callableTarget in listCallablesInline:
 		parametersNumba = None
@@ -124,6 +118,6 @@ def makeFlowNumbaOptimized(listCallablesInline: List[str]
 if __name__ == '__main__':
 	# Z0Z_setDatatypeModuleScalar('numba')
 	# Z0Z_setDecoratorCallable('jit')
-	listCallablesInline: List[str] = ['countInitialize', 'countParallel', 'countSequential']
+	listCallablesInline: list[str] = ['countInitialize', 'countParallel', 'countSequential']
 	callableDispatcher = True
 	makeFlowNumbaOptimized(listCallablesInline, callableDispatcher)

mapFolding/syntheticModules/numbaCount.py

@@ -1,10 +1,10 @@
-from mapFolding import indexMy, indexTrack
-from numba import jit, int64, prange, uint16
+from mapFolding import indexTrack, indexMy
+from numba import int64, prange, uint16, jit
 from numpy import ndarray, dtype, integer
-from typing import Tuple, Any
+from typing import Any
 
 @jit((uint16[:, :, ::1], uint16[::1], uint16[::1], uint16[:, ::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:
+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] > 0:
         if my[indexMy.leaf1ndex.value] <= 1 or track[indexTrack.leafBelow.value, 0] == 1:
             my[indexMy.dimensionsUnconstrained.value] = my[indexMy.dimensionsTotal.value]
@@ -47,7 +47,7 @@ def countInitialize(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer
             return
 
 @jit((uint16[:, :, ::1], int64[::1], uint16[::1], uint16[::1], uint16[:, ::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:
+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()
@@ -101,7 +101,7 @@ def countParallel(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[A
         foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
 
 @jit((uint16[:, :, ::1], int64[::1], uint16[::1], uint16[::1], uint16[:, ::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:
+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]

mapFolding/syntheticModules/numba_doTheNeedful.py

@@ -1,11 +1,11 @@
 from mapFolding import indexMy
-from mapFolding.syntheticModules.numbaCount import countParallel, countSequential, countInitialize
-from numba import jit, int64, uint16
+from mapFolding.syntheticModules.numbaCount import countInitialize, countParallel, countSequential
+from numba import uint16, jit, int64
 from numpy import ndarray, dtype, integer
-from typing import Tuple, Any
+from typing import Any
 
 @jit((uint16[:, :, ::1], int64[::1], uint16[::1], uint16[::1], uint16[::1], uint16[:, ::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 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:
+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)
     if my[indexMy.taskDivisions.value] > 0:
         countParallel(connectionGraph, foldGroups, gapsWhere, my, track)

mapFolding/theDao.py

@@ -1,93 +1,93 @@
 from mapFolding import indexMy, indexTrack
 from numba import prange
 from numpy import dtype, integer, ndarray
-from typing import Any, Tuple
+from typing import Any
 
 # `.value` is not necessary for this module or most modules. But, this module is transformed into Numba "jitted" functions, and Numba won't use `Enum` for an ndarray index without `.value`.
-def activeLeafConnectedToItself(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def activeLeafConnectedToItself(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.leafConnectee.value] == my[indexMy.leaf1ndex.value]
 
-def activeLeafGreaterThan0(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def activeLeafGreaterThan0(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.leaf1ndex.value] > 0
 
-def activeLeafGreaterThanLeavesTotal(foldGroups: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def activeLeafGreaterThanLeavesTotal(foldGroups: ndarray[tuple[int], dtype[integer[Any]]], my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.leaf1ndex.value] > foldGroups[-1]
 
-def activeLeafIsTheFirstLeaf(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def activeLeafIsTheFirstLeaf(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.leaf1ndex.value] <= 1
 
-def allDimensionsAreUnconstrained(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def allDimensionsAreUnconstrained(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return not my[indexMy.dimensionsUnconstrained.value]
 
-def backtrack(my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], 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 countGaps(gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], 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:
 		incrementGap1ndexCeiling(my=my)
 	track[indexTrack.countDimensionsGapped.value, my[indexMy.leafConnectee.value]] += 1
 
-def decrementDimensionsUnconstrained(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def decrementDimensionsUnconstrained(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
 	my[indexMy.dimensionsUnconstrained.value] -= 1
 
-def dimensionsUnconstrainedCondition(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], my: ndarray[Tuple[int], 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 filterCommonGaps(gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], 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]:
 		incrementActiveGap(my=my)
 	track[indexTrack.countDimensionsGapped.value, gapsWhere[my[indexMy.indexMiniGap.value]]] = 0
 
-def incrementActiveGap(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def incrementActiveGap(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
 	my[indexMy.gap1ndex.value] += 1
 
-def incrementGap1ndexCeiling(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def incrementGap1ndexCeiling(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
 	my[indexMy.gap1ndexCeiling.value] += 1
 
-def incrementIndexDimension(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def incrementIndexDimension(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
 	my[indexMy.indexDimension.value] += 1
 
-def incrementIndexMiniGap(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def incrementIndexMiniGap(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
 	my[indexMy.indexMiniGap.value] += 1
 
-def initializeIndexMiniGap(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def initializeIndexMiniGap(my: ndarray[tuple[int], dtype[integer[Any]]]) -> None:
 	my[indexMy.indexMiniGap.value] = my[indexMy.gap1ndex.value]
 
-def initializeLeafConnectee(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]]) -> None:
+def initializeLeafConnectee(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 initializeVariablesToFindGaps(my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
+def initializeVariablesToFindGaps(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 insertUnconstrainedLeaf(gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[Tuple[int], 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 leafBelowSentinelIs1(track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> Any:
+def leafBelowSentinelIs1(track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> Any:
 	return track[indexTrack.leafBelow.value, 0] == 1
 
-def loopingLeavesConnectedToActiveLeaf(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def loopingLeavesConnectedToActiveLeaf(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]
 
-def loopingToActiveGapCeiling(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def loopingToActiveGapCeiling(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.indexMiniGap.value] < my[indexMy.gap1ndexCeiling.value]
 
-def loopUpToDimensionsTotal(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def loopUpToDimensionsTotal(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.indexDimension.value] < my[indexMy.dimensionsTotal.value]
 
-def noGapsHere(my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> Any:
+def noGapsHere(my: ndarray[tuple[int], dtype[integer[Any]]], track: ndarray[tuple[int, int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.leaf1ndex.value] > 0 and my[indexMy.gap1ndex.value] == track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value] - 1]
 
-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:
+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]]]
@@ -96,19 +96,19 @@ def placeLeaf(gapsWhere: ndarray[Tuple[int], dtype[integer[Any]]], my: ndarray[T
 	track[indexTrack.gapRangeStart.value, my[indexMy.leaf1ndex.value]] = my[indexMy.gap1ndex.value]
 	my[indexMy.leaf1ndex.value] += 1
 
-def thereIsAnActiveLeaf(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def thereIsAnActiveLeaf(my: ndarray[tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.leaf1ndex.value] > 0
 
-def thisIsMyTaskIndex(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+def thisIsMyTaskIndex(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 updateLeafConnectee(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:
+def updateLeafConnectee(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 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]]]
+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 activeLeafGreaterThan0(my=my):
@@ -134,11 +134,11 @@ def countInitialize(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer
 		if my[indexMy.gap1ndex.value] > 0:
 			return
 
-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]]]
+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()
@@ -182,11 +182,11 @@ def countParallel(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[A
 				placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
 		foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
 
-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]]]
+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
@@ -216,12 +216,12 @@ def countSequential( connectionGraph: ndarray[Tuple[int, int, int], dtype[intege
 			placeLeaf(gapsWhere=gapsWhere, my=my, track=track)
 	foldGroups[my[indexMy.taskIndex.value]] = groupsOfFolds
 
-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]]]
+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,15 +1,29 @@
-from mapFolding.theSSOTdatatypes import *
+from collections.abc import Callable
+from mapFolding.theSSOTdatatypes import (
+	EnumIndices,
+	indexMy,
+	indexTrack,
+	reportDatatypeLimit,
+	setDatatypeModule,
+	setDatatypeElephino,
+	setDatatypeFoldsTotal,
+	setDatatypeLeavesTotal,
+	getDatatypeModule,
+	setInStone,
+	hackSSOTdtype,
+	hackSSOTdatatype,
+)
 from numba.core.compiler import CompilerBase as numbaCompilerBase
 from numpy import dtype, integer, ndarray
+from pathlib import Path
+from sys import modules as sysModules
 from types import ModuleType
-from typing import Any, Callable, Dict, Final, Tuple, TYPE_CHECKING, Union, cast
-import pathlib
-import sys
+from typing import Any, Final, TYPE_CHECKING, cast
 
 try:
 	from typing import NotRequired
-except ImportError:
-	from typing_extensions import NotRequired
+except Exception:
+	from typing_extensions import NotRequired # type: ignore
 
 if TYPE_CHECKING:
 	from typing import TypedDict
@@ -33,21 +47,21 @@ moduleOfSyntheticModules = "syntheticModules"
 formatFilenameModuleDEFAULT = "numba_{callableTarget}.py"
 dispatcherCallableNameDEFAULT = "doTheNeedful"
 
-def getPathPackage() -> pathlib.Path:
+def getPathPackage() -> Path:
 	import importlib, inspect
-	pathPackage = pathlib.Path(inspect.getfile(importlib.import_module(myPackageNameIs)))
+	pathPackage = 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"
+def getPathJobRootDEFAULT() -> Path:
+	if 'google.colab' in sysModules:
+		pathJobDEFAULT = Path("/content/drive/MyDrive") / "jobs"
 	else:
 		pathJobDEFAULT = getPathPackage() / "jobs"
 	return pathJobDEFAULT
 
-def getPathSyntheticModules() -> pathlib.Path:
+def getPathSyntheticModules() -> Path:
 	pathSyntheticModules = getPathPackage() / moduleOfSyntheticModules
 	return pathSyntheticModules
 
@@ -65,12 +79,12 @@ def getDispatcherCallable() -> Callable[..., None]:
 
 # 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]]]
 
 _datatypeModuleScalar = 'numba'
 _decoratorCallable = 'jit'
@@ -110,7 +124,7 @@ class ParametersNumba(TypedDict):
 	forceinline: bool
 	forceobj: NotRequired[bool]
 	inline: str
-	locals: NotRequired[Dict[str, Any]]
+	locals: NotRequired[dict[str, Any]]
 	looplift: bool
 	no_cfunc_wrapper: bool
 	no_cpython_wrapper: bool
@@ -118,8 +132,8 @@ class ParametersNumba(TypedDict):
 	nogil: NotRequired[bool]
 	nopython: bool
 	parallel: bool
-	pipeline_class: NotRequired[Type[numbaCompilerBase]]
-	signature_or_function: NotRequired[Union[Any, Callable, str, Tuple]]
+	pipeline_class: NotRequired[type[numbaCompilerBase]]
+	signature_or_function: NotRequired[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, }

mapFolding/theSSOTdatatypes.py

@@ -1,21 +1,19 @@
 from collections import defaultdict
-from typing import Any, cast, Dict, Final, Optional, Type, TYPE_CHECKING
+from typing import Any, cast, Final, TYPE_CHECKING
 import enum
-import sys
 import numba
 import numpy
 
 try:
 	from typing import NotRequired
-except ImportError:
-	from typing_extensions import NotRequired
+except Exception:
+	from typing_extensions import NotRequired # type: ignore
 
 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:
@@ -48,7 +46,7 @@ class indexTrack(EnumIndices):
 	countDimensionsGapped	= enum.auto()
 	gapRangeStart			= enum.auto()
 
-_datatypeDefault: Final[Dict[str, str]] = {
+_datatypeDefault: Final[dict[str, str]] = {
 	'elephino': 'uint16',
 	'foldsTotal': 'int64',
 	'leavesTotal': 'uint16',
@@ -56,9 +54,9 @@ _datatypeDefault: Final[Dict[str, str]] = {
 _datatypeModule = ''
 _datatypeModuleDEFAULT: Final[str] = 'numpy'
 
-_datatype: Dict[str, str] = defaultdict(str)
+_datatype: dict[str, str] = defaultdict(str)
 
-def reportDatatypeLimit(identifier: str, datatype: str, sourGrapes: Optional[bool] = False) -> str:
+def reportDatatypeLimit(identifier: str, datatype: str, sourGrapes: bool | None = False) -> str:
 	global _datatype
 	if not _datatype[identifier]:
 		_datatype[identifier] = datatype
@@ -68,7 +66,7 @@ def reportDatatypeLimit(identifier: str, datatype: str, sourGrapes: Optional[boo
 		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:
+def setDatatypeModule(datatypeModule: str, sourGrapes: bool | None = False) -> str:
 	global _datatypeModule
 	if not _datatypeModule:
 		_datatypeModule = datatypeModule
@@ -78,13 +76,13 @@ def setDatatypeModule(datatypeModule: str, sourGrapes: Optional[bool] = False) -
 		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:
+def setDatatypeElephino(datatype: str, sourGrapes: bool | None = False) -> str:
 	return reportDatatypeLimit('elephino', datatype, sourGrapes)
 
-def setDatatypeFoldsTotal(datatype: str, sourGrapes: Optional[bool] = False) -> str:
+def setDatatypeFoldsTotal(datatype: str, sourGrapes: bool | None = False) -> str:
 	return reportDatatypeLimit('foldsTotal', datatype, sourGrapes)
 
-def setDatatypeLeavesTotal(datatype: str, sourGrapes: Optional[bool] = False) -> str:
+def setDatatypeLeavesTotal(datatype: str, sourGrapes: bool | None = False) -> str:
 	return reportDatatypeLimit('leavesTotal', datatype, sourGrapes)
 
 def _get_datatype(identifier: str) -> str:
@@ -104,12 +102,12 @@ def getDatatypeModule() -> str:
 		_datatypeModule = _datatypeModuleDEFAULT
 	return _datatypeModule
 
-def setInStone(identifier: str) -> Type[Any]:
+def setInStone(identifier: str) -> type[Any]:
 	datatypeModule = getDatatypeModule()
 	datatypeStr = _get_datatype(identifier)
-	return cast(Type[Any], getattr(eval(datatypeModule), datatypeStr))
+	return cast(type[Any], getattr(eval(datatypeModule), datatypeStr))
 
-def hackSSOTdtype(identifier: str) -> Type[Any]:
+def hackSSOTdtype(identifier: str) -> type[Any]:
 	_hackSSOTdtype={
 	'connectionGraph': 	'dtypeLeavesTotal',
 	'dtypeElephino': 	'dtypeElephino',

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.4.3
+Version: 0.5.0
 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
@@ -39,6 +39,7 @@ Requires-Dist: pytest-env; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
 Requires-Dist: python_minifier; extra == "testing"
+Requires-Dist: pyupgrade; extra == "testing"
 Requires-Dist: updateCitation; extra == "testing"
 
 # mapFolding: Algorithms for enumerating distinct map/stamp folding patterns 🗺️

mapFolding-0.5.0.dist-info/RECORD

@@ -0,0 +1,39 @@
+mapFolding/__init__.py,sha256=AQA9ypsiV8cDUCvWdM64kFhO9LaKFvAuSEw03jiI7ao,1358
+mapFolding/basecamp.py,sha256=f6Z_KJ1iGV5a3YBDsxS0m7RojYABYlR4kb-dvKW8CAs,3703
+mapFolding/beDRY.py,sha256=ViKLdomPYXD4o86BZwWgT0qPQNKqdtAZ74YoKC9Kgjg,16793
+mapFolding/oeis.py,sha256=Jak0vOfS_gGTXH6xBI7NTUp4Clluvj792E5HNFDDt6U,11149
+mapFolding/theDao.py,sha256=64dlLhrdtNbZAXMbqcZhGAE0ZwgqYRt8nT1on46J-cc,12611
+mapFolding/theSSOT.py,sha256=tcEbPQLmvRWfIyuR0NpeY0Vm6l6L1dUJFyFZjbDo2Gs,6026
+mapFolding/theSSOTdatatypes.py,sha256=OoB9hVfedQejRPxkP-dgLMHS-vqw_0imBvMLBuyLlg0,5829
+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=neb_sFvYMx6dlZxKVmwGjKNrEsK0XaHyE1AJD9S9-nA,2408
+mapFolding/someAssemblyRequired/synthesizeModuleJAX.py,sha256=21Wos8ynlly577EUDqWbbNc9R1qc19r5ysWaz86bCvg,1210
+mapFolding/someAssemblyRequired/synthesizeNumba.py,sha256=6bVbZMnszgz5J81KF-_LQyi6Sw9SwUBD-k8u-mFKADo,16940
+mapFolding/someAssemblyRequired/synthesizeNumbaGeneralized.py,sha256=vu6oYqoZGLNzbd3i8H9B2cEtL9bM1dhmbIpcJeF1NKE,16666
+mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=YRFLuEWcE7Fz4D7vgEwwof5xsrTRY2tIFl69GrFYke8,9050
+mapFolding/someAssemblyRequired/synthesizeNumbaModules.py,sha256=3oUCPU4nnfynhEqSFqIC8BZ1x0lXK0_0_o-hIx8MCPw,5504
+mapFolding/syntheticModules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+mapFolding/syntheticModules/numbaCount.py,sha256=447sbrCINu6wMfpJENguUyAxd6Vej3w98WzyVelz8eg,12900
+mapFolding/syntheticModules/numba_doTheNeedful.py,sha256=8utsCDlcIvOlrjGugaD6DgecoDICIo5_BKhkYtwv-74,1150
+tests/__init__.py,sha256=eg9smg-6VblOr0kisM40CpGnuDtU2JgEEWGDTFVOlW8,57
+tests/conftest.py,sha256=rorOpl3Q1ksGQB-8UyLdUDkYBl9O3M19CvOKrnnzr-4,12296
+tests/test_computations.py,sha256=67dcIj94VM69m912cY1L8HuqnXWl9NFVNhjx3zRNjvA,2831
+tests/test_oeis.py,sha256=4EPJrd359kO019e6whDnERU-gnvMeOeUsHFgor7bA1Y,4686
+tests/test_other.py,sha256=x34TGMWY7YmVtTduC_hlmISMVYemcx_z8_UcMcaNyIk,8375
+tests/test_tasks.py,sha256=J8CET4Z-SYZGdy1-nj-pvVqMl6ujTXJR5ZCYkU4gbUc,2389
+mapFolding-0.5.0.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
+mapFolding-0.5.0.dist-info/METADATA,sha256=rLrgAmUzYgyLQV_mh749XXhiD1RLrol0iHXZpA_10DU,7678
+mapFolding-0.5.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+mapFolding-0.5.0.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
+mapFolding-0.5.0.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
+mapFolding-0.5.0.dist-info/RECORD,,