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

mapFolding/__init__.py

@@ -22,7 +22,7 @@ from mapFolding.theSSOT import (
 # Synthesize modules
 from mapFolding.theSSOT import (
 	formatModuleNameDEFAULT,
-	getAlgorithmCallable,
+	getAlgorithmDispatcher,
 	getAlgorithmSource,
 	getPathJobRootDEFAULT,
 	getPathSyntheticModules,

mapFolding/beDRY.py

@@ -2,6 +2,7 @@
 from mapFolding import (
 	computationState,
 	getPathJobRootDEFAULT,
+	hackSSOTdatatype,
 	hackSSOTdtype,
 	indexMy,
 	indexTrack,
@@ -9,9 +10,9 @@ from mapFolding import (
 	setDatatypeFoldsTotal,
 	setDatatypeLeavesTotal,
 )
-from numpy import integer
+from numpy import dtype, integer, ndarray
 from numpy.typing import DTypeLike, NDArray
-from typing import Any, List, Optional, Sequence, Tuple, Type, Union
+from typing import Any, List, Optional, Sequence, Tuple, Union
 from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
 import numba
 import numpy
@@ -19,7 +20,7 @@ import os
 import pathlib
 import sys
 
-def getFilenameFoldsTotal(mapShape: Union[Sequence[int], numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]]) -> str:
+def getFilenameFoldsTotal(mapShape: Union[Sequence[int], ndarray[Tuple[int], dtype[integer[Any]]]]) -> str:
 	"""Make a standardized filename for the computed value `foldsTotal`.
 
 	The filename takes into account
@@ -67,30 +68,29 @@ def getLeavesTotal(listDimensions: Sequence[int]) -> int:
 
 		return productDimensions
 
-def getPathFilenameFoldsTotal(mapShape: Union[Sequence[int], numpy.ndarray[Tuple[int], numpy.dtype[integer[Any]]]], pathLikeWriteFoldsTotal: Optional[Union[str, os.PathLike[str]]] = None) -> pathlib.Path:
-	"""Get path for folds total file.
+def getPathFilenameFoldsTotal(mapShape: Union[Sequence[int], ndarray[Tuple[int], dtype[integer[Any]]]], pathLikeWriteFoldsTotal: Optional[Union[str, os.PathLike[str]]] = None) -> pathlib.Path:
+	"""Get a standardized path and filename for the computed value `foldsTotal`.
 
-	This function determines the file path for storing fold totals. If a path is provided,
-	it will use that path. If the path is a directory, it will append a default filename.
-	The function ensures the parent directory exists by creating it if necessary.
+	If you provide a directory, the function will append a standardized filename. If you provide a filename
+	or a relative path and filename, the function will prepend the default path.
 
 	Parameters:
-		mapShape (Sequence[int]): List of dimensions for the map folding problem.
-		pathLikeWriteFoldsTotal (Union[str, os.PathLike[str]], optional): Path where to save
-			the folds total. Can be a file path or directory path. If None, uses default path.
+		mapShape: List of dimensions for the map folding problem.
+		pathLikeWriteFoldsTotal (pathJobRootDEFAULT): Path, filename, or relative path and filename. If None, uses default path.
 			Defaults to None.
 
 	Returns:
-		pathlib.Path: Complete path to the folds total file.
+		pathFilenameFoldsTotal: Absolute path and filename.
 	"""
-	pathFilenameFoldsTotal = pathlib.Path(pathLikeWriteFoldsTotal) if pathLikeWriteFoldsTotal is not None else getPathJobRootDEFAULT()
-	if pathFilenameFoldsTotal.is_dir():
-		filenameFoldsTotalDEFAULT = getFilenameFoldsTotal(mapShape)
-		pathFilenameFoldsTotal = pathFilenameFoldsTotal / filenameFoldsTotalDEFAULT
-	elif pathlib.Path(pathLikeWriteFoldsTotal).is_absolute(): # type: ignore
-		pathFilenameFoldsTotal = pathlib.Path(pathLikeWriteFoldsTotal) # type: ignore
+	pathLikeSherpa = pathlib.Path(pathLikeWriteFoldsTotal) if pathLikeWriteFoldsTotal is not None else None
+	if not pathLikeSherpa:
+		pathLikeSherpa = getPathJobRootDEFAULT()
+	if pathLikeSherpa.is_dir():
+		pathFilenameFoldsTotal = pathLikeSherpa / getFilenameFoldsTotal(mapShape)
+	elif pathLikeSherpa.is_absolute():
+		pathFilenameFoldsTotal = pathLikeSherpa
 	else:
-		pathFilenameFoldsTotal = pathlib.Path(getPathJobRootDEFAULT(), pathLikeWriteFoldsTotal) # type: ignore
+		pathFilenameFoldsTotal = getPathJobRootDEFAULT() / pathLikeSherpa
 
 	pathFilenameFoldsTotal.parent.mkdir(parents=True, exist_ok=True)
 	return pathFilenameFoldsTotal
@@ -107,23 +107,23 @@ def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrenc
 		- int: direct set the number of task divisions; cannot exceed the map's total leaves
 		- "maximum": divides into `leavesTotal`-many `taskDivisions`
 		- "cpu": limits the divisions to the number of available CPUs, i.e. `concurrencyLimit`
-	concurrencyLimit:
-		Maximum number of concurrent tasks allowed
-	CPUlimit: for error reporting
-	listDimensions: for error reporting
+		concurrencyLimit:
+			Maximum number of concurrent tasks allowed
+		CPUlimit: for error reporting
+		listDimensions: for error reporting
 
 	Returns
 	-------
-	taskDivisions:
+		taskDivisions:
 
 	Raises
 	------
-	ValueError
-		If computationDivisions is an unsupported type or if resulting task divisions exceed total leaves
+		ValueError
+			If computationDivisions is an unsupported type or if resulting task divisions exceed total leaves
 
 	Notes
 	-----
-	Task divisions cannot exceed total leaves to prevent duplicate counting of folds.
+	Task divisions should not exceed total leaves to prevent duplicate counting of folds.
 	"""
 	taskDivisions = 0
 	leavesTotal = getLeavesTotal(listDimensions)
@@ -145,7 +145,7 @@ def getTaskDivisions(computationDivisions: Optional[Union[int, str]], concurrenc
 
 	return taskDivisions
 
-def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optional[Type]) -> numpy.ndarray[Tuple[int, int, int], numpy.dtype[integer[Any]]]:
+def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optional[str]) -> ndarray[Tuple[int, int, int], dtype[integer[Any]]]:
 	"""
 	Constructs a multi-dimensional connection graph representing the connections between the leaves of a map with the given dimensions.
 	Also called a Cartesian product decomposition or dimensional product mapping.
@@ -157,21 +157,22 @@ def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optio
 	Returns
 		connectionGraph: A 3D numpy array with shape of (dimensionsTotal, leavesTotal + 1, leavesTotal + 1).
 	"""
-	if keywordArguments.get('datatype', None):
-		setDatatypeLeavesTotal(keywordArguments['datatype']) # type: ignore
-	datatype = hackSSOTdtype('connectionGraph')
+	ImaSetTheDatatype = keywordArguments.get('datatype', None)
+	if ImaSetTheDatatype:
+		setDatatypeLeavesTotal(ImaSetTheDatatype)
+	dtype = hackSSOTdtype('connectionGraph')
 	mapShape = validateListDimensions(listDimensions)
 	leavesTotal = getLeavesTotal(mapShape)
-	arrayDimensions = numpy.array(mapShape, dtype=datatype)
+	arrayDimensions = numpy.array(mapShape, dtype=dtype)
 	dimensionsTotal = len(arrayDimensions)
 
-	cumulativeProduct = numpy.multiply.accumulate([1] + mapShape, dtype=datatype)
-	coordinateSystem = numpy.zeros((dimensionsTotal, leavesTotal + 1), dtype=datatype)
+	cumulativeProduct = numpy.multiply.accumulate([1] + mapShape, dtype=dtype)
+	coordinateSystem = numpy.zeros((dimensionsTotal, leavesTotal + 1), dtype=dtype)
 	for indexDimension in range(dimensionsTotal):
 		for leaf1ndex in range(1, leavesTotal + 1):
 			coordinateSystem[indexDimension, leaf1ndex] = ( ((leaf1ndex - 1) // cumulativeProduct[indexDimension]) % arrayDimensions[indexDimension] + 1 )
 
-	connectionGraph = numpy.zeros((dimensionsTotal, leavesTotal + 1, leavesTotal + 1), dtype=datatype)
+	connectionGraph = numpy.zeros((dimensionsTotal, leavesTotal + 1, leavesTotal + 1), dtype=dtype)
 	for indexDimension in range(dimensionsTotal):
 		for activeLeaf1ndex in range(1, leavesTotal + 1):
 			for connectee1ndex in range(1, activeLeaf1ndex + 1):
@@ -190,70 +191,54 @@ def makeConnectionGraph(listDimensions: Sequence[int], **keywordArguments: Optio
 	return connectionGraph
 
 def makeDataContainer(shape: Union[int, Tuple[int, ...]], datatype: Optional[DTypeLike] = None) -> NDArray[integer[Any]]:
-	"""Create a zeroed-out `numpy.ndarray` with the given shape and datatype.
+	"""Create a zeroed-out `ndarray` with the given shape and datatype.
 
 	Parameters:
-		shape (Union[int, Tuple[int, ...]]): The shape of the array. Can be an integer for 1D arrays
+		shape: The shape of the array. Can be an integer for 1D arrays
 			or a tuple of integers for multi-dimensional arrays.
-		datatype (Optional[DTypeLike], optional): The desired data type for the array.
+		datatype: The desired data type for the array.
 			If None, defaults to dtypeLargeDEFAULT. Defaults to None.
 
 	Returns:
-		numpy.ndarray: A new array of given shape and type, filled with zeros.
+		dataContainer: A new array of given shape and type, filled with zeros.
 	"""
 	if datatype is None:
 		datatype = hackSSOTdtype('dtypeFoldsTotal')
 	return numpy.zeros(shape, dtype=datatype)
 
-def outfitCountFolds(listDimensions: Sequence[int]
-						, computationDivisions: Optional[Union[int, str]] = None
-						, CPUlimit: Optional[Union[bool, float, int]] = None
-						, **keywordArguments: Optional[Union[str, bool]]) -> computationState:
+def outfitCountFolds(listDimensions: Sequence[int], computationDivisions: Optional[Union[int, str]] = None, CPUlimit: Optional[Union[bool, float, int]] = None, **keywordArguments: Optional[Union[str, bool]]) -> computationState:
 	"""
 	Initializes and configures the computation state for map folding computations.
 
-	Parameters
-	----------
-	listDimensions:
-		The dimensions of the map to be folded
-	computationDivisions (None):
-		Specifies how to divide computations:
-		- None: no division of the computation into tasks; sets task divisions to 0
-		- int: direct set the number of task divisions; cannot exceed the map's total leaves
-		- "maximum": divides into `leavesTotal`-many `taskDivisions`
-		- "cpu": limits the divisions to the number of available CPUs, i.e. `concurrencyLimit`
-	CPUlimit (None):
-		Whether and how to limit the CPU usage. See notes for details.
-	**keywordArguments:
-		Datatype management.
-
-	Returns
-	-------
-	computationState
-		An initialized computation state containing:
-		- connectionGraph: Graph representing connections in the map
-		- foldsSubTotals: Array tracking total folds
-		- mapShape: Validated and sorted dimensions of the map
-		- my: Array for internal state tracking
-		- gapsWhere: Array tracking gap positions
-		- the: Static settings and metadata
-		- track: Array for tracking computation progress
+	Parameters:
+		listDimensions: The dimensions of the map to be folded
+		computationDivisions (None): see `getTaskDivisions`
+		CPUlimit (None): see `setCPUlimit`
+		**keywordArguments: Datatype management.
 
-	Limits on CPU usage `CPUlimit`:
-		- `False`, `None`, or `0`: No limits on CPU usage; uses all available CPUs. All other values will potentially limit CPU usage.
-		- `True`: Yes, limit the CPU usage; limits to 1 CPU.
-		- Integer `>= 1`: Limits usage to the specified number of CPUs.
-		- Decimal value (`float`) between 0 and 1: Fraction of total CPUs to use.
-		- Decimal value (`float`) between -1 and 0: Fraction of CPUs to *not* use.
-		- Integer `<= -1`: Subtract the absolute value from total CPUs.
+	Returns:
+		stateInitialized: The initialized computation state
 	"""
-	kwourGrapes = keywordArguments.get('sourGrapes', False)
-	kwatatype = keywordArguments.get('datatypeElephino', None)
-	if kwatatype: setDatatypeElephino(kwatatype, sourGrapes=kwourGrapes) # type: ignore
-	kwatatype = keywordArguments.get('datatypeFoldsTotal', None)
-	if kwatatype: setDatatypeFoldsTotal(kwatatype, sourGrapes=kwourGrapes) # type: ignore
-	kwatatype = keywordArguments.get('datatypeLeavesTotal', None)
-	if kwatatype: setDatatypeLeavesTotal(kwatatype, sourGrapes=kwourGrapes) # type: ignore
+	kwourGrapes = keywordArguments.get('sourGrapes', None)
+	if kwourGrapes:
+		sourGrapes = True
+	else:
+		sourGrapes = False
+
+	ImaSetTheDatatype = keywordArguments.get('datatypeElephino', None)
+	if ImaSetTheDatatype:
+		ImaSetTheDatatype = str(ImaSetTheDatatype)
+		setDatatypeElephino(ImaSetTheDatatype, sourGrapes)
+
+	ImaSetTheDatatype = keywordArguments.get('datatypeFoldsTotal', None)
+	if ImaSetTheDatatype:
+		ImaSetTheDatatype = str(ImaSetTheDatatype)
+		setDatatypeFoldsTotal(ImaSetTheDatatype, sourGrapes)
+
+	ImaSetTheDatatype = keywordArguments.get('datatypeLeavesTotal', None)
+	if ImaSetTheDatatype:
+		ImaSetTheDatatype = str(ImaSetTheDatatype)
+		setDatatypeLeavesTotal(ImaSetTheDatatype, sourGrapes)
 
 	my = makeDataContainer(len(indexMy), hackSSOTdtype('my'))
 
@@ -268,7 +253,7 @@ def outfitCountFolds(listDimensions: Sequence[int]
 	my[indexMy.dimensionsTotal] = len(mapShape)
 	my[indexMy.leaf1ndex] = 1
 	stateInitialized = computationState(
-		connectionGraph = makeConnectionGraph(mapShape, datatype=hackSSOTdtype('connectionGraph')),
+		connectionGraph = makeConnectionGraph(mapShape, datatype=hackSSOTdatatype('connectionGraph')),
 		foldGroups = foldGroups,
 		mapShape = numpy.array(mapShape, dtype=hackSSOTdtype('mapShape')),
 		my = my,

mapFolding/oeis.py

@@ -37,31 +37,31 @@ settingsOEIShardcodedValues: Dict[str, Dict[str, Any]] = {
 		'getMapShape': lambda n: sorted([2, n]),
 		'valuesBenchmark': [14],
 		'valuesTestParallelization': [*range(3, 7)],
-		'valuesTestValidation': [0, 1, random.randint(2, 9)],
+		'valuesTestValidation': [random.randint(2, 9)],
 	},
 	'A001416': {
 		'getMapShape': lambda n: sorted([3, n]),
 		'valuesBenchmark': [9],
 		'valuesTestParallelization': [*range(3, 5)],
-		'valuesTestValidation': [0, 1, random.randint(2, 6)],
+		'valuesTestValidation': [random.randint(2, 6)],
 	},
 	'A001417': {
 		'getMapShape': lambda n: [2] * n,
 		'valuesBenchmark': [6],
 		'valuesTestParallelization': [*range(2, 4)],
-		'valuesTestValidation': [0, 1, random.randint(2, 4)],
+		'valuesTestValidation': [random.randint(2, 4)],
 	},
 	'A195646': {
 		'getMapShape': lambda n: [3] * n,
 		'valuesBenchmark': [3],
 		'valuesTestParallelization': [*range(2, 3)],
-		'valuesTestValidation': [0, 1, 2],
+		'valuesTestValidation': [2],
 	},
 	'A001418': {
 		'getMapShape': lambda n: [n, n],
 		'valuesBenchmark': [5],
 		'valuesTestParallelization': [*range(2, 4)],
-		'valuesTestValidation': [1, random.randint(2, 4)],
+		'valuesTestValidation': [random.randint(2, 4)],
 	},
 }
 
@@ -229,7 +229,7 @@ def makeSettingsOEIS() -> Dict[str, SettingsOEIS]:
 			getMapShape=settingsOEIShardcodedValues[oeisID]['getMapShape'],
 			valuesBenchmark=settingsOEIShardcodedValues[oeisID]['valuesBenchmark'],
 			valuesTestParallelization=settingsOEIShardcodedValues[oeisID]['valuesTestParallelization'],
-			valuesTestValidation=settingsOEIShardcodedValues[oeisID]['valuesTestValidation'],
+			valuesTestValidation=settingsOEIShardcodedValues[oeisID]['valuesTestValidation'] + list(range(offsetSherpa, 2)),
 			valuesKnown=valuesKnownSherpa,
 			valueUnknown=max(valuesKnownSherpa.keys(), default=0) + 1
 		)

mapFolding/someAssemblyRequired/__init__.py

@@ -1,2 +1,5 @@
 from mapFolding.someAssemblyRequired.getLLVMforNoReason import writeModuleLLVM
 from mapFolding.someAssemblyRequired.makeJob import makeStateJob
+from mapFolding.someAssemblyRequired.synthesizeNumbaGeneralized import youOughtaKnow
+from mapFolding.someAssemblyRequired.synthesizeNumbaJob import writeJobNumba
+from mapFolding.someAssemblyRequired.synthesizeNumbaModules import makeFlowNumbaOptimized

mapFolding/someAssemblyRequired/makeJob.py

@@ -5,15 +5,9 @@ import pathlib
 import pickle
 
 @overload
-def makeStateJob(listDimensions: Sequence[int], *, writeJob: Literal[True]
-				 , **keywordArguments: Optional[str]) -> pathlib.Path:
-	...
-
+def makeStateJob(listDimensions: Sequence[int], *, writeJob: Literal[True] , **keywordArguments: Optional[str]) -> pathlib.Path: ...
 @overload
-def makeStateJob(listDimensions: Sequence[int], *, writeJob: Literal[False]
-				 , **keywordArguments: Optional[str]) -> computationState:
-	...
-
+def makeStateJob(listDimensions: Sequence[int], *, writeJob: Literal[False] , **keywordArguments: Optional[str]) -> computationState: ...
 def makeStateJob(listDimensions: Sequence[int], *, writeJob: bool = True, **keywordArguments: Optional[Any]) -> computationState | pathlib.Path:
 	"""
 	Creates a computation state job for map folding calculations and optionally saves it to disk.

mapFolding/someAssemblyRequired/synthesizeNumba.py

@@ -16,11 +16,11 @@ def insertArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: str, arra
 
 	def insertAssign(assignee: str, arraySlice: numpy.ndarray) -> None:
 		nonlocal FunctionDefTarget
-		onlyDataRLE = makeStrRLEcompacted(arraySlice) #NOTE
+		onlyDataRLE = autoDecodingRLE(arraySlice, addSpaces=True)
 		astStatement = cast(ast.Expr, ast.parse(onlyDataRLE).body[0])
 		dataAst = astStatement.value
 
-		arrayCall = Then.make_astCall(name=constructorName, args=[dataAst], dictionaryKeywords={'dtype': ast.Name(id=argData_dtypeName, ctx=ast.Load())})
+		arrayCall = Then.make_astCall(name=constructorName, args=[dataAst], list_astKeywords=[ast.keyword(arg='dtype', value=ast.Name(id=argData_dtypeName, ctx=ast.Load()))])
 
 		assignment = ast.Assign(targets=[ast.Name(id=assignee, ctx=ast.Store())], value=arrayCall)#NOTE
 		FunctionDefTarget.body.insert(0, assignment)
@@ -51,15 +51,15 @@ def findAndReplaceArrayIn_body(FunctionDefTarget: ast.FunctionDef, identifier: s
 				if isinstance(astSubscript.value, ast.Name) and astSubscript.value.id == identifier and isinstance(astSubscript.slice, ast.Attribute):
 					indexAs_astAttribute: ast.Attribute = astSubscript.slice
 					indexAsStr = ast.unparse(indexAs_astAttribute)
-					argDataSlice = arrayTarget[eval(indexAsStr)]
+					arraySlice = arrayTarget[eval(indexAsStr)]
 
-					onlyDataRLE = makeStrRLEcompacted(argDataSlice)
+					onlyDataRLE = autoDecodingRLE(arraySlice, addSpaces=True)
 					astStatement = cast(ast.Expr, ast.parse(onlyDataRLE).body[0])
 					dataAst = astStatement.value
 
-					arrayCall = Then.make_astCall(name=constructorName, args=[dataAst], dictionaryKeywords={'dtype': ast.Name(id=argData_dtypeName, ctx=ast.Load())})
+					arrayCall = Then.make_astCall(name=constructorName, args=[dataAst], list_astKeywords=[ast.keyword(arg='dtype', value=ast.Name(id=argData_dtypeName, ctx=ast.Load()))])
 
-					assignment = ast.Assign( targets=[astAssignee], value=arrayCall )
+					assignment = ast.Assign(targets=[astAssignee], value=arrayCall)
 					FunctionDefTarget.body.insert(0, assignment)
 					FunctionDefTarget.body.remove(stmt)
 	return FunctionDefTarget, allImports
@@ -77,7 +77,7 @@ def findAndReplaceArraySubscriptIn_body(FunctionDefTarget: ast.FunctionDef, iden
 					indexAs_astAttribute: ast.Attribute = astSubscript.slice
 					indexAsStr = ast.unparse(indexAs_astAttribute)
 					argDataSlice: int = arrayTarget[eval(indexAsStr)].item()
-					astCall = ast.Call(func=ast.Name(id=argData_dtypeName, ctx=ast.Load()) , args=[ast.Constant(value=argDataSlice)], keywords=[])
+					astCall = ast.Call(func=ast.Name(id=argData_dtypeName, ctx=ast.Load()), args=[ast.Constant(value=argDataSlice)], keywords=[])
 					assignment = ast.Assign(targets=[astAssignee], value=astCall)
 					if astAssignee.id not in Z0Z_listChaff:
 						FunctionDefTarget.body.insert(0, assignment)
@@ -252,6 +252,7 @@ def makeAstModuleForOneCallable(pythonSource: str, callableTarget: str, paramete
 	if inlineCallables:
 		dictionaryFunctionDef = {statement.name: statement for statement in astModule.body if isinstance(statement, ast.FunctionDef)}
 		callableInlinerWorkhorse = RecursiveInliner(dictionaryFunctionDef)
+		# NOTE the inliner assumes each function is not called more than once
 		FunctionDefTarget = callableInlinerWorkhorse.inlineFunctionBody(callableTarget)
 	else:
 		FunctionDefTarget = next((node for node in astModule.body if isinstance(node, ast.FunctionDef) and node.name == callableTarget), None)

mapFolding/someAssemblyRequired/synthesizeNumbaGeneralized.py

@@ -3,6 +3,7 @@ from mapFolding import (
 	EnumIndices,
 	formatModuleNameDEFAULT,
 	FREAKOUT,
+	getAlgorithmDispatcher,
 	getAlgorithmSource,
 	getFilenameFoldsTotal,
 	getPathFilenameFoldsTotal,
@@ -35,6 +36,7 @@ from numpy import integer
 from numpy.typing import NDArray
 from types import ModuleType
 from typing import Any, Callable, cast, Dict, List, Optional, Sequence, Set, Tuple, Type, Union
+from Z0Z_tools import autoDecodingRLE
 import ast
 import autoflake
 import collections
@@ -50,54 +52,6 @@ import python_minifier
 
 youOughtaKnow = collections.namedtuple('youOughtaKnow', ['callableSynthesized', 'pathFilenameForMe', 'astForCompetentProgrammers'])
 
-# TODO move to Z0Z_tools
-def makeStrRLEcompacted(arrayTarget: NDArray[integer[Any]]) -> str:
-	"""Converts a NumPy array into a compressed string representation using run-length encoding (RLE).
-
-	This function takes a NumPy array and converts it into an optimized string representation by:
-	1. Compressing consecutive sequences of numbers into range objects
-	2. Minimizing repeated zeros using array multiplication syntax
-
-	Parameters:
-		arrayTarget (numpy.ndarray): The input NumPy array to be converted
-
-	Returns:
-		str: A string containing Python code that recreates the input array in compressed form.
-	"""
-
-	def compressRangesNDArrayNoFlatten(arraySlice: NDArray[integer[Any]]) -> List[List[Any] | Any | NDArray[integer[Any]]] | List[Any] | Any | NDArray[integer[Any]]:
-		if isinstance(arraySlice, numpy.ndarray) and arraySlice.ndim > 1:
-			return [compressRangesNDArrayNoFlatten(arraySlice[index]) for index in range(arraySlice.shape[0])]
-		elif isinstance(arraySlice, numpy.ndarray) and arraySlice.ndim == 1:
-			listWithRanges = []
-			for group in more_itertools.consecutive_groups(arraySlice.tolist()):
-				ImaSerious = list(group)
-				ImaRange = [range(ImaSerious[0], ImaSerious[-1] + 1)]
-				spaces = True #NOTE
-				lengthAsList = spaces*(len(ImaSerious)-1) + len(python_minifier.minify(str(ImaSerious))) # brackets are proxies for commas
-				lengthAsRange = spaces*1 + len(str('*')) + len(python_minifier.minify(str(ImaRange))) # brackets are proxies for commas
-				if lengthAsRange < lengthAsList:
-					listWithRanges += ImaRange
-				else:
-					listWithRanges += ImaSerious
-			return listWithRanges
-		return arraySlice
-
-	arrayAsNestedLists = compressRangesNDArrayNoFlatten(arrayTarget)
-
-	arrayAsStr = python_minifier.minify(str(arrayAsNestedLists))
-
-	commaIntMaximum = arrayTarget.shape[-1] - 1
-
-	for X in range(1):
-		arrayAsStr = arrayAsStr.replace(f'[{X}' + f',{X}'*commaIntMaximum + ']', f'[{X}]*'+str(commaIntMaximum+1))
-		for countInt in range(commaIntMaximum, 2, -1):
-			arrayAsStr = arrayAsStr.replace(f',{X}'*countInt + ']', f']+[{X}]*'+str(countInt))
-
-	arrayAsStr = arrayAsStr.replace('range', '*range')
-
-	return arrayAsStr
-
 # Generic
 class ifThis:
 	"""Generic AST node predicate builder."""

mapFolding/someAssemblyRequired/synthesizeNumbaJob.py

@@ -28,9 +28,9 @@ def doUnrollCountGaps(FunctionDefTarget: ast.FunctionDef, stateJob: computationS
 	return FunctionDefTarget, allImports
 
 def writeJobNumba(mapShape: Sequence[int]
-				, callableTarget: str
 				, algorithmSource: ModuleType
-				, parametersNumba: Optional[ParametersNumba]=None
+				, callableTarget: Optional[str] = None
+				, parametersNumba: Optional[ParametersNumba] = None
 				, pathFilenameWriteJob: Optional[Union[str, os.PathLike[str]]] = None
 				, unrollCountGaps: Optional[bool] = False
 				, **keywordArguments: Optional[Any]
@@ -63,7 +63,15 @@ def writeJobNumba(mapShape: Sequence[int]
 	stateJob = makeStateJob(mapShape, writeJob=False, **keywordArguments)
 	pythonSource = inspect.getsource(algorithmSource)
 	astModule = ast.parse(pythonSource)
-	FunctionDefTarget = next((node for node in astModule.body if isinstance(node, ast.FunctionDef) and node.name == callableTarget), None)
+	setFunctionDef = {statement for statement in astModule.body if isinstance(statement, ast.FunctionDef)}
+	if not callableTarget:
+		if len(setFunctionDef) == 1:
+			FunctionDefTarget = setFunctionDef.pop()
+			callableTarget = FunctionDefTarget.name
+		else:
+			raise ValueError(f"I did not receive a `callableTarget` and {algorithmSource.__name__=} has more than one callable: {setFunctionDef}. Please select one.")
+	else:
+		FunctionDefTarget = setFunctionDef.pop() if callableTarget in {statement.name for statement in setFunctionDef} else None
 	if not FunctionDefTarget: raise ValueError(f"I received `{callableTarget=}` and {algorithmSource.__name__=}, but I could not find that function in that source.")
 
 	# NOTE `allImports` is a complementary container to `FunctionDefTarget`; the `FunctionDefTarget` cannot track its own imports very well.
@@ -116,6 +124,21 @@ def writeJobNumba(mapShape: Sequence[int]
 	ast.fix_missing_locations(astModule)
 	pythonSource = ast.unparse(astModule)
 	pythonSource = autoflake.fix_code(pythonSource, ['mapFolding', 'numba', 'numpy'])
+	pythonSource = python_minifier.minify(pythonSource, remove_annotations = False,
+		remove_pass = False,
+		remove_literal_statements = False,
+		combine_imports = True,
+		hoist_literals = False,
+		rename_locals = False,
+		rename_globals = False,
+		remove_object_base = False,
+		convert_posargs_to_args = False,
+		preserve_shebang = True,
+		remove_asserts = False,
+		remove_debug = False,
+		remove_explicit_return_none = False,
+		remove_builtin_exception_brackets = False,
+		constant_folding = False)
 
 	# NOTE put on disk
 	if pathFilenameWriteJob is None:
@@ -132,11 +155,11 @@ def writeJobNumba(mapShape: Sequence[int]
 
 if __name__ == '__main__':
 	mapShape = [5,5]
-	callableTarget = 'countSequential'
-
 	from mapFolding.syntheticModules import numba_countSequential
 	algorithmSource: ModuleType = numba_countSequential
 
+	callableTarget = None
+
 	parametersNumba = parametersNumbaDEFAULT
 
 	pathFilenameWriteJob = None
@@ -147,4 +170,4 @@ if __name__ == '__main__':
 	Z0Z_setDatatypeModuleScalar('numba')
 	Z0Z_setDecoratorCallable('jit')
 
-	writeJobNumba(mapShape, callableTarget, algorithmSource, parametersNumba, pathFilenameWriteJob)
+	writeJobNumba(mapShape, algorithmSource, callableTarget, parametersNumba, pathFilenameWriteJob)

mapFolding/someAssemblyRequired/synthesizeNumbaModules.py

@@ -4,7 +4,7 @@ everything I am doing. I would rather benefit from humanity's
 collective wisdom."""
 from mapFolding.someAssemblyRequired.synthesizeNumba import *
 
-def makeFlowNumbaOptimized(listCallablesInline: List[str], callableDispatcher: Optional[str] = None, algorithmSource: Optional[ModuleType] = None, relativePathWrite: Optional[pathlib.Path] = None, formatFilenameWrite: Optional[str] = None) -> None:
+def makeFlowNumbaOptimized(listCallablesInline: List[str], callableDispatcher: Optional[bool] = False, algorithmSource: Optional[ModuleType] = None, relativePathWrite: Optional[pathlib.Path] = None, formatFilenameWrite: Optional[str] = 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:
@@ -51,7 +51,7 @@ def makeFlowNumbaOptimized(listCallablesInline: List[str], callableDispatcher: O
 		listStuffYouOughtaKnow.append(doThisStuff(callableTarget, parametersNumba, inlineCallables, unpackArrays, allImports, relativePathWrite, formatFilenameWrite))
 
 	if callableDispatcher:
-		callableTarget 	= callableDispatcher
+		callableTarget 	= getAlgorithmDispatcher().__name__
 		parametersNumba = None
 		inlineCallables	= False
 		unpackArrays	= False
@@ -63,6 +63,8 @@ def makeFlowNumbaOptimized(listCallablesInline: List[str], callableDispatcher: O
 
 		listStuffYouOughtaKnow.append(doThisStuff(callableTarget, parametersNumba, inlineCallables, unpackArrays, allImports, relativePathWrite, formatFilenameWrite))
 
+	return listStuffYouOughtaKnow
+
 if __name__ == '__main__':
 	setDatatypeModule('numpy', sourGrapes=True)
 	setDatatypeFoldsTotal('int64', sourGrapes=True)
@@ -71,5 +73,5 @@ if __name__ == '__main__':
 	Z0Z_setDatatypeModuleScalar('numba')
 	Z0Z_setDecoratorCallable('jit')
 	listCallablesInline: List[str] = ['countInitialize', 'countParallel', 'countSequential']
-	callableDispatcher = 'doTheNeedful'
+	callableDispatcher = True
 	makeFlowNumbaOptimized(listCallablesInline, callableDispatcher)

mapFolding/syntheticModules/numba_countInitialize.py

@@ -1,12 +1,12 @@
 from mapFolding import indexMy
 from mapFolding import indexTrack
-from numba import uint8
 from numba import jit
-from numpy import integer
+from numba import uint8
 from numpy import dtype
 from numpy import ndarray
-from typing import Any
+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:

mapFolding/syntheticModules/numba_countParallel.py

@@ -1,14 +1,14 @@
 from mapFolding import indexMy
 from mapFolding import indexTrack
-from numba import uint8
-from numba import jit
-from numba import int64
 from numba import prange
-from numpy import integer
+from numba import int64
+from numba import jit
+from numba import uint8
 from numpy import dtype
 from numpy import ndarray
-from typing import Any
+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:

mapFolding/syntheticModules/numba_countSequential.py

@@ -1,13 +1,13 @@
 from mapFolding import indexMy
 from mapFolding import indexTrack
-from numba import uint8
-from numba import jit
 from numba import int64
-from numpy import integer
+from numba import jit
+from numba import uint8
 from numpy import dtype
 from numpy import ndarray
-from typing import Any
+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:
@@ -34,10 +34,10 @@ def countSequential(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer
                 gap1ndexCeiling = gapRangeStart[leaf1ndex - 1]
                 indexDimension = 0
                 while indexDimension < dimensionsTotal:
-                    if connectionGraph[indexDimension, leaf1ndex, leaf1ndex] == leaf1ndex:
+                    leafConnectee = connectionGraph[indexDimension, leaf1ndex, leaf1ndex]
+                    if leafConnectee == leaf1ndex:
                         dimensionsUnconstrained -= 1
                     else:
-                        leafConnectee = connectionGraph[indexDimension, leaf1ndex, leaf1ndex]
                         while leafConnectee != leaf1ndex:
                             gapsWhere[gap1ndexCeiling] = leafConnectee
                             if countDimensionsGapped[leafConnectee] == 0:

mapFolding/syntheticModules/numba_doTheNeedful.py

@@ -2,14 +2,14 @@ from mapFolding.syntheticModules.numba_countInitialize import countInitialize
 from mapFolding.syntheticModules.numba_countParallel import countParallel
 from mapFolding.syntheticModules.numba_countSequential import countSequential
 from mapFolding import indexMy
-from numba import uint8
-from numba import jit
 from numba import int64
-from numpy import integer
+from numba import jit
+from numba import uint8
 from numpy import dtype
 from numpy import ndarray
-from typing import Any
+from numpy import integer
 from typing import Tuple
+from typing import Any
 
 @jit((uint8[:, :, ::1], int64[::1], 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 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:

mapFolding/theDao.py

@@ -78,6 +78,9 @@ def leafConnecteeInitialization(connectionGraph: ndarray[Tuple[int, int, int], d
 def leafConnecteeUpdate(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[Any]]], my: ndarray[Tuple[int], dtype[integer[Any]]], track: ndarray[Tuple[int, int], dtype[integer[Any]]]) -> None:
 	my[indexMy.leafConnectee.value] = connectionGraph[my[indexMy.indexDimension.value], my[indexMy.leaf1ndex.value], track[indexTrack.leafBelow.value, my[indexMy.leafConnectee.value]]]
 
+def activeLeafConnectedToItself(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
+	return my[indexMy.leafConnectee.value] == my[indexMy.leaf1ndex.value]
+
 def loopingLeavesConnectedToActiveLeaf(my: ndarray[Tuple[int], dtype[integer[Any]]]) -> Any:
 	return my[indexMy.leafConnectee.value] != my[indexMy.leaf1ndex.value]
 
@@ -103,9 +106,9 @@ def thereAreComputationDivisionsYouMightSkip(my: ndarray[Tuple[int], dtype[integ
 	return my[indexMy.leaf1ndex.value] != my[indexMy.taskDivisions.value] or my[indexMy.leafConnectee.value] % my[indexMy.taskDivisions.value] == my[indexMy.taskIndex.value]
 
 def countInitialize(connectionGraph: 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]]]
+						, gapsWhere: ndarray[Tuple[int]			 , dtype[integer[Any]]]
+						,		 my: ndarray[Tuple[int]			 , dtype[integer[Any]]]
+						,	  track: ndarray[Tuple[int, int]	 , dtype[integer[Any]]]
 					) -> None:
 
 	while activeLeafGreaterThan0Condition(my=my):
@@ -132,10 +135,10 @@ def countInitialize(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer
 			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]]]
+					,  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,8 +185,8 @@ def countParallel(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[A
 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]]]
+						,		  my: ndarray[Tuple[int]		  , dtype[integer[Any]]]
+						,	   track: ndarray[Tuple[int, int]	  , dtype[integer[Any]]]
 					) -> None:
 
 	groupsOfFolds: int = 0
@@ -195,10 +198,10 @@ def countSequential( connectionGraph: ndarray[Tuple[int, int, int], dtype[intege
 			else:
 				findGapsInitializeVariables(my=my, track=track)
 				while loopUpToDimensionsTotal(my=my):
-					if dimensionsUnconstrainedCondition(connectionGraph=connectionGraph, my=my):
+					leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
+					if activeLeafConnectedToItself(my=my):
 						dimensionsUnconstrainedDecrement(my=my)
 					else:
-						leafConnecteeInitialization(connectionGraph=connectionGraph, my=my)
 						while loopingLeavesConnectedToActiveLeaf(my=my):
 							countGaps(gapsWhere=gapsWhere, my=my, track=track)
 							leafConnecteeUpdate(connectionGraph=connectionGraph, my=my, track=track)
@@ -217,8 +220,8 @@ def doTheNeedful(connectionGraph: ndarray[Tuple[int, int, int], dtype[integer[An
 					, 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]]]
+					,		  my: ndarray[Tuple[int]		  , dtype[integer[Any]]]
+					,	   track: ndarray[Tuple[int, int]	  , dtype[integer[Any]]]
 					) -> None:
 
 	countInitialize(connectionGraph, gapsWhere, my, track)

mapFolding/theSSOT.py

@@ -82,9 +82,9 @@ def getAlgorithmSource() -> ModuleType:
 	from mapFolding import theDao
 	return theDao
 
-def getAlgorithmCallable() -> Callable[..., None]:
+def getAlgorithmDispatcher() -> Callable[..., None]:
 	algorithmSource = getAlgorithmSource()
-	return cast(Callable[..., None], algorithmSource.doTheNeedful)
+	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

mapFolding/theSSOTnumba.py

@@ -18,23 +18,16 @@ Old notes that are not entirely accurate.
 
 | **Option**			  | **Description**									 | **Why**			   | **Size**		| **But**				  |
 | ----------------------- | --------------------------------------------------- | --------------------- | --------------- | ------------------------ |
-| `_dbg_extend_lifetimes` | Debug option to extend object lifetimes			 | Debugging			 |				 |						  |
-| `_dbg_optnone`		  | Disable optimization for debugging				  | Debugging			 |				 |						  |
-| `debug`				 | Enable debug mode with additional checks			| Debugging			 |				 |						  |
 | `no_rewrites`		   | Disable AST rewrites optimization				   | Debugging			 |				 |						  |
-| `boundscheck`		   | Enable array bounds checking (slows execution)	  | Error checking		| Larger		  | Slower				   |
 | `error_model`		   | Divide by zero: kill or chill?					  | Error checking		| ?			   |						  |
 | `_nrt`				  | Enable No Runtime type checking					 | Startup speed		 | Smaller		 | No type protection	   |
-| `fastmath`			  | Reduce float potential precision					| Float speed		   | Smaller		 | Discriminatory, untested |
 | `forceinline`		   | Force function inlining							 | Reduce function calls | Likely larger   |						  |
-| `forceobj`			  | Force object mode compilation					   | Inclusiveness		 | Larger		  | Slower execution		 |
 | `inline`				| Algorithmically choose inlining					 | Speed				 | Slightly larger |						  |
 | `looplift`			  | Enable loop lifting optimization					| Speed (if applicable) | Larger		  | Exclusionary			 |
 | `no_cfunc_wrapper`	  | Disable C function wrapper generation			   | Size				  | Smaller		 | Exclusionary			 |
 | `no_cpython_wrapper`	| Disable Python C-API wrapper generation			 | Size				  | Smallest		| Exclusionary			 |
 
 """
-# 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]

{mapFolding-0.4.0.dist-info → mapFolding-0.4.2.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.2
 Name: mapFolding
-Version: 0.4.0
+Version: 0.4.2
 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
 Project-URL: Donate, https://www.patreon.com/integrated
 Project-URL: Homepage, https://github.com/hunterhogan/mapFolding
 Project-URL: Repository, https://github.com/hunterhogan/mapFolding.git
-Keywords: A001415,A001416,A001417,A001418,A195646,folding,map folding,OEIS,stamp folding
+Keywords: A001415,A001416,A001417,A001418,A195646,combinatorics,folding,map folding,OEIS,optimization,stamp folding
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Education
@@ -16,8 +16,14 @@ Classifier: Intended Audience :: Other Audience
 Classifier: Intended Audience :: Science/Research
 Classifier: Natural Language :: English
 Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python
 Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Description-Content-Type: text/markdown
@@ -25,17 +31,14 @@ License-File: LICENSE
 Requires-Dist: numba
 Requires-Dist: numpy
 Requires-Dist: Z0Z_tools
-Provides-Extra: synthesizemodules
-Requires-Dist: autoflake; extra == "synthesizemodules"
-Requires-Dist: more_itertools; extra == "synthesizemodules"
-Requires-Dist: python_minifier; extra == "synthesizemodules"
 Provides-Extra: testing
-Requires-Dist: mypy; extra == "testing"
+Requires-Dist: autoflake; extra == "testing"
+Requires-Dist: more_itertools; extra == "testing"
 Requires-Dist: pytest-cov; extra == "testing"
 Requires-Dist: pytest-env; extra == "testing"
-Requires-Dist: pytest-mypy; extra == "testing"
 Requires-Dist: pytest-xdist; extra == "testing"
 Requires-Dist: pytest; extra == "testing"
+Requires-Dist: python_minifier; extra == "testing"
 Requires-Dist: updateCitation; extra == "testing"
 
 # mapFolding: Algorithms for enumerating distinct map/stamp folding patterns 🗺️
@@ -104,6 +107,35 @@ Available OEIS sequences:
 - Transform the algorithm using AST
 - Create hyper-optimized modules to compute a specific map.
 
+### 4. **Customizing your algorithm**
+
+- mapFolding\someAssemblyRequired\synthesizeNumbaJob.py (and/or synthesizeNumba____.py, as applicable)
+  - Synthesize a Numba-optimized module for a specific mapShape
+  - Synthesize _from_ a module in mapFolding\syntheticModules or from any source you select
+  - Use the existing transformation options
+  - Or create new ways of transforming the algorithm from its source to a specific job
+- mapFolding\someAssemblyRequired\makeJob.py
+  - Initialize data for a specific mapShape
+- mapFolding\someAssemblyRequired\synthesizeNumbaModules.py (and/or synthesizeNumba____.py, as applicable)
+  - Synthesize one or more Numba-optimized modules for parallel or sequential computation
+  - Overwrite the modules in mapFolding\syntheticModules or save the module(s) to a custom path
+  - Synthesize _from_ the algorithm(s) in mapFolding\theDao.py or from any source you select
+  - Use the existing transformation options
+  - Or create new ways of transforming the algorithm from its source to a new module
+  - Use your new module in synthesizeNumbaJob.py, above, as the source to create a mapShape-specific job module
+- mapFolding\theDao.py
+  - Modify the algorithms for initializing values, parallel computation, and/or sequential computation
+  - Use the modified algorithm(s) in synthesizeNumbaModules.py, above, to create Numba-optimized version(s)
+  - Then use a Numba-optimized version in synthesizeNumbaJob.py, above, to create a hyper-optimized version for a specific mapShape
+- mapFolding\theSSOT.py (and/or theSSOTnumba.py and/ or theSSOT____.py, if they exist)
+  - Modify broad settings or find functions to modify broad settings, such as data structures and their data types
+  - Create new settings or groups of settings
+- mapFolding\beDRY.py
+  - Functions to handle common tasks, such as parsing parameters or creating the `connectionGraph` for a mapShape (a Cartesian product decomposition)
+- mapFolding\someAssemblyRequired
+  - Create new transformations to optimize the algorithm, such as for JAX, CuPy, or CUDA
+  - (mapFolding\reference\jax.py has a once-functional JAX implementation, and synthesizeModuleJAX.py might be a useful starting point)
+
 ## Map-folding Video
 
 ~~This caused my neurosis:~~ I enjoyed the following video, which is what introduced me to map folding.

mapFolding-0.4.2.dist-info/RECORD

@@ -0,0 +1,42 @@
+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/conftest.py

@@ -3,11 +3,13 @@
 # TODO learn how to run tests and coverage analysis without `env = ["NUMBA_DISABLE_JIT=1"]`
 
 from mapFolding import *
-from mapFolding import basecamp, getAlgorithmCallable, getDispatcherCallable
+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 typing import Any, Callable, ContextManager, Dict, Generator, List, Optional, Sequence, Set, Tuple, Type, Union
+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 pathlib
 import pytest
@@ -50,7 +52,8 @@ def setupTeardownTmpObjects() -> Generator[None, None, None]:
 
 @pytest.fixture
 def pathTmpTesting(request: pytest.FixtureRequest) -> pathlib.Path:
-	pathTmp = pathTmpRoot / str(uuid.uuid4().hex)
+	# "Z0Z_" ensures the directory name does not start with a number, which would make it an invalid Python identifier
+	pathTmp = pathTmpRoot / ("Z0Z_" + str(uuid.uuid4().hex))
 	pathTmp.mkdir(parents=True, exist_ok=False)
 
 	registrarRecordsTmpObject(pathTmp)
@@ -63,9 +66,10 @@ def pathFilenameTmpTesting(request: pytest.FixtureRequest) -> pathlib.Path:
 	except AttributeError:
 		extension = ".txt"
 
+	# "Z0Z_" ensures the name does not start with a number, which would make it an invalid Python identifier
 	uuidHex = uuid.uuid4().hex
-	subpath = uuidHex[0:-8]
-	filenameStem = uuidHex[-8:None]
+	subpath = "Z0Z_" + uuidHex[0:-8]
+	filenameStem = "Z0Z_" + uuidHex[-8:None]
 
 	pathFilenameTmp = pathlib.Path(pathTmpRoot, subpath, filenameStem + extension)
 	pathFilenameTmp.parent.mkdir(parents=True, exist_ok=False)
@@ -97,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
 
 """
@@ -229,17 +203,27 @@ def oeisID_1random() -> str:
 	return random.choice(oeisIDsImplemented)
 
 @pytest.fixture
-def useAlgorithmDirectly() -> Generator[None, Any, None]:
-	"""Temporarily patches getDispatcherCallable to return the algorithm source directly."""
-	original_dispatcher = basecamp.getDispatcherCallable
+def useThisDispatcher():
+	"""A fixture providing a context manager for temporarily replacing the dispatcher.
 
-	# Patch the function at module level
-	basecamp.getDispatcherCallable = getAlgorithmCallable
+	Returns
+		A context manager for patching the dispatcher
+	"""
+	dispatcherOriginal = basecamp.getDispatcherCallable
 
-	yield
+	def patchDispatcher(callableTarget: Callable) -> None:
+		def callableParameterized(*arguments: Any, **keywordArguments: Any) -> Callable:
+			return callableTarget
+		basecamp.getDispatcherCallable = callableParameterized
 
-	# Restore original function
-	basecamp.getDispatcherCallable = original_dispatcher
+	yield patchDispatcher
+	basecamp.getDispatcherCallable = dispatcherOriginal
+
+@pytest.fixture
+def useAlgorithmSourceDispatcher(useThisDispatcher: Callable) -> Generator[None, None, None]:
+	"""Temporarily patches getDispatcherCallable to return the algorithm dispatcher."""
+	useThisDispatcher(getAlgorithmDispatcher())
+	yield
 
 def uniformTestMessage(expected: Any, actual: Any, functionName: str, *arguments: Any) -> str:
 	"""Format assertion message for any test comparison."""

tests/test_computations.py

@@ -0,0 +1,79 @@
+from pathlib import Path
+from tests.conftest import *
+import importlib.util
+import pytest
+
+def test_algorithmSourceParallel(listDimensionsTestParallelization: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int], useAlgorithmSourceDispatcher: None) -> None:
+	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
+
+def test_algorithmSourceSequential(listDimensionsTestCountFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int], useAlgorithmSourceDispatcher: None) -> None:
+	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestCountFolds)], countFolds, listDimensionsTestCountFolds)
+
+def test_aOFn_calculate_value(oeisID: str) -> None:
+	for n in settingsOEIS[oeisID]['valuesTestValidation']:
+		standardizedEqualTo(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
+
+# Python doesn't want me to test this
+# @pytest.mark.parametrize('pathFilenameTmpTesting', ['.py'], indirect=True)
+# def test_writeJobNumba(listDimensionsTestCountFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int], pathFilenameTmpTesting: Path) -> None:
+# 	from mapFolding.syntheticModules import numba_countSequential
+# 	algorithmSourceHARDCODED: ModuleType = numba_countSequential
+# 	algorithmSource = algorithmSourceHARDCODED
+# 	pathFilenameModule = writeJobNumba(listDimensionsTestCountFolds, algorithmSource, pathFilenameWriteJob=pathFilenameTmpTesting.absolute())
+
+# 	Don_Lapre_Road_to_Self_Improvement = importlib.util.spec_from_file_location("__main__", pathFilenameModule)
+# 	if Don_Lapre_Road_to_Self_Improvement is None:
+# 		raise ImportError(f"Failed to create module specification from {pathFilenameModule}")
+# 	if Don_Lapre_Road_to_Self_Improvement.loader is None:
+# 		raise ImportError(f"Failed to get loader for module {pathFilenameModule}")
+# 	module = importlib.util.module_from_spec(Don_Lapre_Road_to_Self_Improvement)
+
+# 	module.__name__ = "__main__"
+# 	Don_Lapre_Road_to_Self_Improvement.loader.exec_module(module)
+
+# 	pathFilenameFoldsTotal = getPathFilenameFoldsTotal(listDimensionsTestCountFolds)
+# 	standardizedEqualTo(str(foldsTotalKnown[tuple(listDimensionsTestCountFolds)]), pathFilenameFoldsTotal.read_text().strip)
+
+# def test_makeFlowNumbaOptimized(pathTmpTesting: Path, useThisDispatcher):
+# def test_makeFlowNumbaOptimized(useThisDispatcher):
+# 	"""To get this to work:
+# 	walk_up=True doesn't work on 3.10, so that has to go
+# 	the _logical_ import must be in the logical path of the package
+# 	fuck python
+# 	"""
+# 	listCallablesInlineHARDCODED: List[str] = ['countInitialize', 'countParallel', 'countSequential']
+# 	listCallablesInline = listCallablesInlineHARDCODED
+# 	callableDispatcher = True
+# 	algorithmSource = None
+# 	relativePathWrite = None
+# 	# relativePathWrite = pathTmpTesting.absolute().relative_to(getPathPackage(), walk_up=True)
+# 	formatFilenameWrite = "pytest_{callableTarget}"
+# 	listSynthesizedModules: List[youOughtaKnow] = makeFlowNumbaOptimized(listCallablesInline, callableDispatcher, algorithmSource, relativePathWrite, formatFilenameWrite)
+# 	for stuff in listSynthesizedModules:
+# 		registrarRecordsTmpObject(stuff.pathFilenameForMe)
+# 		if stuff.callableSynthesized not in listCallablesInline:
+# 			dispatcherSynthetic: youOughtaKnow = stuff
+# 	if not dispatcherSynthetic: raise FREAKOUT
+# 		# dispatcherSynthetic: youOughtaKnow = next(filter(lambda x: x.callableSynthesized not in listCallablesInline, listSynthesizedModules))
+
+# 	# Import the synthetic dispatcher module to get the callable
+# 	dispatcherSpec = importlib.util.spec_from_file_location(
+# 		dispatcherSynthetic.callableSynthesized,
+# 		dispatcherSynthetic.pathFilenameForMe
+# 	)
+# 	if dispatcherSpec is None:
+# 		raise ImportError(f"Failed to create module specification from {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)
+
+# 	def test_syntheticSequential(listDimensionsTestCountFolds: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]):
+# 		standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestCountFolds)], countFolds, listDimensionsTestCountFolds)
+
+# 	def test_syntheticParallel(listDimensionsTestParallelization: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int]):
+# 		standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')

tests/test_oeis.py

@@ -2,7 +2,6 @@ from contextlib import redirect_stdout
 from datetime import datetime, timedelta
 from mapFolding.oeis import _getFilenameOEISbFile, _getOEISidValues, _parseBFileOEIS, _validateOEISid, _getOEISidInformation
 from tests.conftest import *
-from typing import NoReturn
 from urllib.error import URLError
 import io
 import os
@@ -15,14 +14,6 @@ import unittest.mock
 import urllib
 import urllib.request
 
-def test_algorithmSourceSequential(oeisID: str, useAlgorithmDirectly: None) -> None:
-	for n in settingsOEIS[oeisID]['valuesTestValidation']:
-		standardizedEqualTo(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
-
-def test_aOFn_calculate_value(oeisID: str) -> None:
-	for n in settingsOEIS[oeisID]['valuesTestValidation']:
-		standardizedEqualTo(settingsOEIS[oeisID]['valuesKnown'][n], oeisIDfor_n, oeisID, n)
-
 @pytest.mark.parametrize("badID", ["A999999", "  A999999  ", "A999999extra"])
 def test__validateOEISid_invalid_id(badID: str) -> None:
 	standardizedEqualTo(KeyError, _validateOEISid, badID)

tests/test_other.py

@@ -1,6 +1,5 @@
 from contextlib import redirect_stdout
 from tests.conftest import *
-from typing import Dict, List, Any, Literal, Callable, Generator, Optional, Union
 from Z0Z_tools import intInnit
 import io
 import itertools

tests/test_tasks.py

@@ -1,13 +1,9 @@
 from tests.conftest import *
-from typing import List, Dict, Literal, Tuple
 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_algorithmSourceParallel(listDimensionsTestParallelization: List[int], foldsTotalKnown: Dict[Tuple[int, ...], int], useAlgorithmDirectly: None) -> None:
-	standardizedEqualTo(foldsTotalKnown[tuple(listDimensionsTestParallelization)], countFolds, listDimensionsTestParallelization, None, 'maximum')
-
 def test_countFoldsComputationDivisionsInvalid(listDimensionsTestFunctionality: List[int]) -> None:
 	standardizedEqualTo(ValueError, countFolds, listDimensionsTestFunctionality, None, {"wrong": "value"})
 

mapFolding-0.4.0.dist-info/RECORD

@@ -1,41 +0,0 @@
-mapFolding/__init__.py,sha256=6HgDJ2_-lnTMVwXDhTs36MgQT6Ph0kYVvuvkeUP2u9w,1321
-mapFolding/basecamp.py,sha256=v0VCF_Zgm_XBHcz4bqblsxfHwAxZKgenW6um77quWLk,3751
-mapFolding/beDRY.py,sha256=XVtLraG9VnC4yG2HkaFwZRh2td4ZHMjTQvnbcD_W130,17133
-mapFolding/oeis.py,sha256=rTMK4aQXxudmUGS-RkzikmSIPLdottVgJHKwY0atZqg,11120
-mapFolding/theDao.py,sha256=ktYQSsF6pQrWA0bj6UVbvTsWgZP8mlEj1JKGQeqeFuI,12701
-mapFolding/theSSOT.py,sha256=anbFOL2daNLcy9SuO_4EyFFlPsnKSpkvyO11Zf4QCoU,10174
-mapFolding/theSSOTnumba.py,sha256=zGq2zlZZeuxiNSO2Fs_AqV6UhybJAJuDw-2lMVvDS2w,5133
-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=nqW7FcV65IS0tctqzzJ0MDex_z24es8OGYApzKcx1Ys,144
-mapFolding/someAssemblyRequired/getLLVMforNoReason.py,sha256=nX8tghZClYt7zJd6RpZBXhE_h-CGRHOS17biqiEdf-o,855
-mapFolding/someAssemblyRequired/makeJob.py,sha256=TZBJHgAEJ6c5XU4DHuyQgKOY-nf19Fvvoicyzn2huG0,2436
-mapFolding/someAssemblyRequired/synthesizeModuleJAX.py,sha256=jatvtYhK5ZJK-YmCKATt7w3icFXXO79cZDAYVrU9bgA,1258
-mapFolding/someAssemblyRequired/synthesizeNumba.py,sha256=949ZrnKy8rFsgZy8I5e82RMoFdCnVM9JML1l7lW-rOQ,17226
-mapFolding/someAssemblyRequired/synthesizeNumbaGeneralized.py,sha256=9Xa-ftqDScsvhs-2zq5vsJ6LofCdaz1hMUbKPF49vPE,16080
-mapFolding/someAssemblyRequired/synthesizeNumbaJob.py,sha256=5q8ROqNHODy_WacVZq0vu4AHjqfwuS6mOmRZQWQ_XWE,8128
-mapFolding/someAssemblyRequired/synthesizeNumbaModules.py,sha256=1V8tF-pjcmpFIywZuC-_i1EN3KsQAvI0SnIlzlXxDCs,3731
-mapFolding/syntheticModules/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-mapFolding/syntheticModules/numba_countInitialize.py,sha256=6-OlRBCEAKstJm-E0cs4VjPolYxiz9zSNvUGU6BRoTg,4274
-mapFolding/syntheticModules/numba_countParallel.py,sha256=64HHCOPOnsw7bSuLClaWpeH6C8D1aksZSDj8b_xQJec,5517
-mapFolding/syntheticModules/numba_countSequential.py,sha256=1_V4cIqiqKO2lvvc5IyNEX3ElMJs3ZiWB3HUU3sjdMI,3732
-mapFolding/syntheticModules/numba_doTheNeedful.py,sha256=koAKvwn5gUO4gVoeXaA12qguZAYz_Tso42xAH9UVw8o,1368
-tests/__init__.py,sha256=eg9smg-6VblOr0kisM40CpGnuDtU2JgEEWGDTFVOlW8,57
-tests/conftest.py,sha256=gZTZlqW814yucdRhtSV6IsfAM67QgoW5rkdvlveyEFQ,11095
-tests/test_oeis.py,sha256=72mL0MtBEYCh58t_qP8qvt6s9kV1fDk4Z9xVEapaapQ,5367
-tests/test_other.py,sha256=fg7t8zW7zG26mw7d06E5cLfirhDrCjelMjwFAZ0C2KM,8433
-tests/test_tasks.py,sha256=jjp-PzxrXMG9L7BBP_2NYLel5xlm-I552wLu3c_a4rw,2741
-tests/test_types.py,sha256=58tmPG9WOeGGAQbdQK_h_7t4SnENnZugH4WXlI8-L-M,171
-mapFolding-0.4.0.dist-info/LICENSE,sha256=NxH5Y8BdC-gNU-WSMwim3uMbID2iNDXJz7fHtuTdXhk,19346
-mapFolding-0.4.0.dist-info/METADATA,sha256=H82VPfUNoVNwkEeSSDHSD6JzB05x1vEl7ADd1y-7Ht8,5241
-mapFolding-0.4.0.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-mapFolding-0.4.0.dist-info/entry_points.txt,sha256=F3OUeZR1XDTpoH7k3wXuRb3KF_kXTTeYhu5AGK1SiOQ,146
-mapFolding-0.4.0.dist-info/top_level.txt,sha256=1gP2vFaqPwHujGwb3UjtMlLEGN-943VSYFR7V4gDqW8,17
-mapFolding-0.4.0.dist-info/RECORD,,