mapFolding 0.4.0__tar.gz → 0.4.2__tar.gz

{mapfolding-0.4.0 → mapfolding-0.4.2}/PKG-INFO

@@ -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.0 → mapfolding-0.4.2}/README.md

@@ -64,6 +64,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.0 → mapfolding-0.4.2}/mapFolding/__init__.py

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

{mapfolding-0.4.0 → mapfolding-0.4.2}/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-0.4.0 → mapfolding-0.4.2}/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-0.4.2/mapFolding/someAssemblyRequired/__init__.py

@@ -0,0 +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-0.4.0 → mapfolding-0.4.2}/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-0.4.0 → mapfolding-0.4.2}/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-0.4.0 → mapfolding-0.4.2}/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-0.4.0 → mapfolding-0.4.2}/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)