mapFolding 0.9.4__tar.gz → 0.10.0__tar.gz

{mapfolding-0.9.4 → mapfolding-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.9.4
+Version: 0.10.0
 Summary: Map folding algorithm with code transformation framework for optimizing numerical computations
 Author-email: Hunter Hogan <HunterHogan@pm.me>
 License: CC-BY-NC-4.0
@@ -41,6 +41,7 @@ Requires-Dist: platformdirs
 Requires-Dist: python_minifier
 Requires-Dist: sympy
 Requires-Dist: tomli
+Requires-Dist: typeshed_client
 Requires-Dist: Z0Z_tools
 Provides-Extra: testing
 Requires-Dist: mypy; extra == "testing"

{mapfolding-0.9.4 → mapfolding-0.10.0}/mapFolding/__init__.py

@@ -44,7 +44,41 @@ allowing users to compute map folding totals for larger dimensions than previous
 foundation for exploring advanced code transformation techniques.
 """
 
-from mapFolding.datatypes import (
+from typing import Any, TypeAlias
+import sys
+
+stuPyd: TypeAlias = Any
+
+if sys.version_info >= (3, 12):
+	from ast import (
+		ParamSpec as astDOTParamSpec,
+		type_param as astDOTtype_param,
+		TypeAlias as astDOTTypeAlias,
+		TypeVar as astDOTTypeVar,
+		TypeVarTuple as astDOTTypeVarTuple,
+	)
+else:
+	astDOTParamSpec: TypeAlias = stuPyd
+	astDOTtype_param: TypeAlias = stuPyd
+	astDOTTypeAlias: TypeAlias = stuPyd
+	astDOTTypeVar: TypeAlias = stuPyd
+	astDOTTypeVarTuple: TypeAlias = stuPyd
+
+if sys.version_info >= (3, 11):
+	from ast import TryStar as astDOTTryStar
+	from typing import TypedDict as TypedDict
+	from typing import NotRequired as NotRequired
+else:
+	astDOTTryStar: TypeAlias = stuPyd
+	try:
+		from typing_extensions import TypedDict as TypedDict
+		from typing_extensions import NotRequired as NotRequired
+	except Exception:
+		TypedDict = dict[stuPyd, stuPyd]
+		from collections.abc import Iterable
+		NotRequired: TypeAlias = Iterable
+
+from mapFolding.datatypes import (  # noqa: E402
 	Array1DElephino as Array1DElephino,
 	Array1DFoldsTotal as Array1DFoldsTotal,
 	Array1DLeavesTotal as Array1DLeavesTotal,
@@ -58,18 +92,18 @@ from mapFolding.datatypes import (
 	NumPyLeavesTotal as NumPyLeavesTotal,
 )
 
-from mapFolding.theSSOT import (
+from mapFolding.theSSOT import (  # noqa: E402
 	ComputationState as ComputationState,
 	raiseIfNoneGitHubIssueNumber3 as raiseIfNoneGitHubIssueNumber3,
 	The as The,
 )
 
-from mapFolding.theDao import (
+from mapFolding.theDao import (  # noqa: E402
 	countInitialize as countInitialize,
 	doTheNeedful as doTheNeedful,
 )
 
-from mapFolding.beDRY import (
+from mapFolding.beDRY import (  # noqa: E402
 	getLeavesTotal as getLeavesTotal,
 	getTaskDivisions as getTaskDivisions,
 	outfitCountFolds as outfitCountFolds,
@@ -77,7 +111,7 @@ from mapFolding.beDRY import (
 	validateListDimensions as validateListDimensions,
 )
 
-from mapFolding.toolboxFilesystem import (
+from mapFolding.toolboxFilesystem import (  # noqa: E402
 	getPathFilenameFoldsTotal as getPathFilenameFoldsTotal,
 	getPathRootJobDEFAULT as getPathRootJobDEFAULT,
 	saveFoldsTotal as saveFoldsTotal,
@@ -85,9 +119,9 @@ from mapFolding.toolboxFilesystem import (
 	writeStringToHere as writeStringToHere,
 )
 
-from mapFolding.Z0Z_flowControl import countFolds
+from mapFolding.basecamp import countFolds as countFolds  # noqa: E402
 
-from mapFolding.oeis import (
+from mapFolding.oeis import (  # noqa: E402
 	clearOEIScache as clearOEIScache,
 	getFoldsTotalKnown as getFoldsTotalKnown,
 	getOEISids as getOEISids,

mapfolding-0.9.4/mapFolding/Z0Z_flowControl.py → mapfolding-0.10.0/mapFolding/basecamp.py

@@ -1,3 +1,14 @@
+"""
+Public API for the map folding algorithm with simplified interface.
+
+This module provides the main entry point for users of the mapFolding package, abstracting away the complexities of the
+computational algorithm. It offers a high-level interface to count the total number of possible ways to fold a
+rectangular map of specified dimensions, with options for customizing the computation process and saving results.
+
+The primary function is countFolds, which handles parameter validation, computation state management, dispatching to the
+appropriate algorithm implementation, and optional persistence of results.
+"""
+
 from collections.abc import Sequence
 from mapFolding import (
 	ComputationState,
@@ -22,7 +33,53 @@ def countFolds(listDimensions: Sequence[int] | None = None
 				, oeis_n: int | None = None
 				, flow: str | None = None
 				) -> int:
-
+	"""
+	Count the total number of possible foldings for a given map dimensions.
+
+	This function serves as the main public interface to the map folding algorithm, handling all parameter validation,
+	computation state management, and result persistence in a user-friendly way.
+
+	Parameters
+	----------
+	listDimensions
+		List of integers representing the dimensions of the map to be folded.
+	pathLikeWriteFoldsTotal: None
+		Path, filename, or pathFilename to write the total fold count to. If a directory is provided, creates a file
+		with a default name based on map dimensions.
+	computationDivisions: None
+		Whether and how to divide the computational work.
+		- `None`: no division of the computation into tasks; sets task divisions to 0.
+		- int: directly 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
+		This is only relevant if there are `computationDivisions`: whether and how to limit the CPU usage.
+		- `False`, `None`, or `0`: No limits on processor usage; uses all available processors. All other values will
+		potentially limit processor usage.
+		- `True`: Yes, limit the processor usage; limits to 1 processor.
+		- Integer `>= 1`: Limits usage to the specified number of processors.
+		- Decimal value (`float`) between 0 and 1: Fraction of total processors to use.
+		- Decimal value (`float`) between -1 and 0: Fraction of processors to _not_ use.
+		- Integer `<= -1`: Subtract the absolute value from total processors.
+
+	Returns
+	-------
+	foldsTotal: Total number of distinct ways to fold a map of the given dimensions.
+
+	Note well
+	---------
+	You probably do not want to divide your computation into tasks.
+
+	If you want to compute a large `foldsTotal`, dividing the computation into tasks is usually a bad idea. Dividing the
+	algorithm into tasks is inherently inefficient: efficient division into tasks means there would be no overlap in the
+	work performed by each task. When dividing this algorithm, the amount of overlap is between 50% and 90% by all
+	tasks: at least 50% of the work done by every task must be done by _all_ tasks. If you improve the computation time,
+	it will only change by -10 to -50% depending on (at the very least) the ratio of the map dimensions and the number
+	of leaves. If an undivided computation would take 10 hours on your computer, for example, the computation will still
+	take at least 5 hours but you might reduce the time to 9 hours. Most of the time, however, you will increase the
+	computation time. If logicalCores >= `leavesTotal`, it will probably be faster. If logicalCores <= 2 * `leavesTotal`, it
+	will almost certainly be slower for all map dimensions.
+	"""
 	# mapShape =====================================================================
 
 	if mapShape:
@@ -87,6 +144,18 @@ def countFolds(listDimensions: Sequence[int] | None = None
 
 		foldsTotal = mapFoldingState.foldsTotal
 
+	elif flow == 'theorem2Trimmed' and any((dimension > 2 for dimension in mapShape)):
+		from mapFolding.dataBaskets import MapFoldingState
+		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
+
+		from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
+		mapFoldingState = initializeGroupsOfFolds(mapFoldingState)
+
+		from mapFolding.syntheticModules.theorem2Trimmed import count
+		mapFoldingState = count(mapFoldingState)
+
+		foldsTotal = mapFoldingState.foldsTotal
+
 	elif (flow == 'theorem2Numba' or taskDivisions == 0) and any((dimension > 2 for dimension in mapShape)):
 		from mapFolding.dataBaskets import MapFoldingState
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)

{mapfolding-0.9.4 → mapfolding-0.10.0}/mapFolding/beDRY.py

@@ -59,14 +59,12 @@ def getTaskDivisions(computationDivisions: int | str | None, concurrencyLimit: i
 	"""
 	Determines whether to divide the computation into tasks and how many divisions.
 
+
 	Parameters
 	----------
 	computationDivisions: None
-		Specifies how to divide computations:
-		- `None`: no division of the computation into tasks; sets task divisions to 0.
-		- int: directly 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`.
+		Specifies how to divide computations: Please see the documentation in `countFolds` for details. I know it is
+		annoying, but I want to be sure you have the most accurate information.
 	concurrencyLimit
 		Maximum number of concurrent tasks allowed.
 
@@ -224,7 +222,7 @@ def outfitCountFolds(mapShape: tuple[int, ...], computationDivisions: int | str
 		A tuple of integers representing the dimensions of the map.
 	computationDivisions: None
 		Controls how to divide the computation into parallel tasks. I know it is annoying, but please see
-		`getTaskDivisions` for details, so that you and I both know you have the most accurate information.
+		`countFolds` for details, so that you and I both know you have the most accurate information.
 	concurrencyLimit: 1
 		Maximum number of concurrent processes to use during computation.
 
@@ -245,19 +243,13 @@ def outfitCountFolds(mapShape: tuple[int, ...], computationDivisions: int | str
 
 def setProcessorLimit(CPUlimit: Any | None, concurrencyPackage: str | None = None) -> int:
 	"""
-	Sets processor limit for concurrent operations.
+	Whether and how to limit the CPU usage.
 
 	Parameters
 	----------
 	CPUlimit: None
-		Controls processor usage limits:
-		- `False`, `None`, or `0`: No limits on processor usage; uses all available processors. All other values will
-		potentially limit processor usage.
-		- `True`: Yes, limit the processor usage; limits to 1 processor.
-		- Integer `>= 1`: Limits usage to the specified number of processors.
-		- Decimal value (`float`) between 0 and 1: Fraction of total processors to use.
-		- Decimal value (`float`) between -1 and 0: Fraction of processors to _not_ use.
-		- Integer `<= -1`: Subtract the absolute value from total processors.
+		Please see the documentation for in `countFolds` for details. I know it is annoying, but I want to be sure you
+		have the most accurate information.
 	concurrencyPackage: None
 		Specifies which concurrency package to use:
 		- `None` or `'multiprocessing'`: Uses standard `multiprocessing`.

{mapfolding-0.9.4 → mapfolding-0.10.0}/mapFolding/dataBaskets.py

@@ -47,3 +47,15 @@ class MapFoldingState:
 		if self.gapRangeStart is None: self.gapRangeStart = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['gapRangeStart'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
 		if self.leafAbove is None: self.leafAbove = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafAbove'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
 		if self.leafBelow is None: self.leafBelow = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['leafBelow'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
+
+@dataclasses.dataclass
+class LeafSequenceState(MapFoldingState):
+	leafSequence: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+
+	def __post_init__(self) -> None:
+		super().__post_init__()
+		from mapFolding.oeis import getFoldsTotalKnown
+		groupsOfFoldsKnown = getFoldsTotalKnown(self.mapShape) // self.leavesTotal
+		if self.leafSequence is None: # pyright: ignore[reportUnnecessaryComparison]
+			self.leafSequence = makeDataContainer(groupsOfFoldsKnown, self.__dataclass_fields__['leafSequence'].metadata['dtype'])
+			self.leafSequence[self.groupsOfFolds] = self.leaf1ndex

{mapfolding-0.9.4 → mapfolding-0.10.0}/mapFolding/datatypes.py

@@ -1,4 +1,4 @@
-from numpy import dtype, int64 as numpy_int64, integer, ndarray
+from numpy import dtype, uint8 as numpy_uint8, uint16 as numpy_uint16, uint64 as numpy_uint64, integer, ndarray
 from typing import Any, TypeAlias, TypeVar
 
 # =============================================================================
@@ -7,13 +7,13 @@ from typing import Any, TypeAlias, TypeVar
 NumPyIntegerType = TypeVar('NumPyIntegerType', bound=integer[Any], covariant=True)
 
 DatatypeLeavesTotal: TypeAlias = int
-NumPyLeavesTotal: TypeAlias = numpy_int64
+NumPyLeavesTotal: TypeAlias = numpy_uint8
 
 DatatypeElephino: TypeAlias = int
-NumPyElephino: TypeAlias = numpy_int64
+NumPyElephino: TypeAlias = numpy_uint16
 
 DatatypeFoldsTotal: TypeAlias = int
-NumPyFoldsTotal: TypeAlias = numpy_int64
+NumPyFoldsTotal: TypeAlias = numpy_uint64
 
 Array3D: TypeAlias = ndarray[tuple[int, int, int], dtype[NumPyLeavesTotal]]
 Array1DLeavesTotal: TypeAlias = ndarray[tuple[int], dtype[NumPyLeavesTotal]]

{mapfolding-0.9.4 → mapfolding-0.10.0}/mapFolding/oeis.py

@@ -20,9 +20,9 @@ mathematical definition in OEIS and the computational implementation in the pack
 from collections.abc import Callable
 from datetime import datetime, timedelta
 from functools import cache
-from mapFolding import countFolds, The, writeStringToHere
+from mapFolding import countFolds, The, TypedDict, writeStringToHere
 from pathlib import Path
-from typing import Any, Final, TYPE_CHECKING
+from typing import Any, Final
 import argparse
 import random
 import sys
@@ -31,11 +31,6 @@ import urllib.request
 import urllib.response
 import warnings
 
-if TYPE_CHECKING:
-	from typing import TypedDict
-else:
-	TypedDict = dict[Any, Any]
-
 cacheDays = 30
 
 pathCache: Path = The.pathPackage / ".cache"

{mapfolding-0.9.4 → mapfolding-0.10.0}/mapFolding/someAssemblyRequired/RecipeJob.py

@@ -1,12 +1,12 @@
-from mapFolding.someAssemblyRequired import ShatteredDataclass, ast_Identifier, parsePathFilename2astModule, str_nameDOTname
+from mapFolding.someAssemblyRequired import ShatteredDataclass, ast_Identifier, parseLogicalPath2astModule, parsePathFilename2astModule, str_nameDOTname
 from mapFolding.someAssemblyRequired.toolboxNumba import theNumbaFlow
 from mapFolding.someAssemblyRequired.transformationTools import shatter_dataclassesDOTdataclass
 from mapFolding.theSSOT import ComputationState, DatatypeElephino as TheDatatypeElephino, DatatypeFoldsTotal as TheDatatypeFoldsTotal, DatatypeLeavesTotal as TheDatatypeLeavesTotal
 from mapFolding.toolboxFilesystem import getPathFilenameFoldsTotal, getPathRootJobDEFAULT
-
-import dataclasses
+from mapFolding.dataBaskets import MapFoldingState
 from pathlib import Path, PurePosixPath
 from typing import TypeAlias
+import dataclasses
 
 @dataclasses.dataclass
 class RecipeJob:
@@ -101,3 +101,97 @@ class RecipeJob:
 	dataclassInstanceTaskDistribution: ast_Identifier = sourceDataclassInstanceTaskDistribution
 	concurrencyManagerNamespace: ast_Identifier = sourceConcurrencyManagerNamespace
 	concurrencyManagerIdentifier: ast_Identifier = sourceConcurrencyManagerIdentifier
+
+@dataclasses.dataclass
+class RecipeJobTheorem2Numba:
+	state: MapFoldingState
+	# TODO create function to calculate `foldsTotalEstimated`
+	foldsTotalEstimated: int = 0
+	shatteredDataclass: ShatteredDataclass = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
+
+	# ========================================
+	# Source
+	source_astModule = parseLogicalPath2astModule('mapFolding.syntheticModules.theorem2Numba')
+	sourceCountCallable: ast_Identifier = 'count'
+
+	sourceLogicalPathModuleDataclass: str_nameDOTname = 'mapFolding.dataBaskets'
+	sourceDataclassIdentifier: ast_Identifier = 'MapFoldingState'
+	sourceDataclassInstance: ast_Identifier = theNumbaFlow.dataclassInstance
+
+	sourcePathPackage: PurePosixPath | None = theNumbaFlow.pathPackage
+	sourcePackageIdentifier: ast_Identifier | None = theNumbaFlow.packageIdentifier
+
+	# ========================================
+	# Filesystem (names of physical objects)
+	pathPackage: PurePosixPath | None = None
+	pathModule: PurePosixPath | None = PurePosixPath(getPathRootJobDEFAULT())
+	""" `pathModule` will override `pathPackage` and `logicalPathRoot`."""
+	fileExtension: str = theNumbaFlow.fileExtension
+	pathFilenameFoldsTotal: PurePosixPath = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
+
+	# ========================================
+	# Logical identifiers (as opposed to physical identifiers)
+	packageIdentifier: ast_Identifier | None = None
+	logicalPathRoot: str_nameDOTname | None = None
+	""" `logicalPathRoot` likely corresponds to a physical filesystem directory."""
+	moduleIdentifier: ast_Identifier = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
+	countCallable: ast_Identifier = sourceCountCallable
+	dataclassIdentifier: ast_Identifier | None = sourceDataclassIdentifier
+	dataclassInstance: ast_Identifier | None = sourceDataclassInstance
+	logicalPathModuleDataclass: str_nameDOTname | None = sourceLogicalPathModuleDataclass
+
+	# ========================================
+	# Datatypes
+	DatatypeFoldsTotal: TypeAlias = TheDatatypeFoldsTotal
+	DatatypeElephino: TypeAlias = TheDatatypeElephino
+	DatatypeLeavesTotal: TypeAlias = TheDatatypeLeavesTotal
+
+	def _makePathFilename(self,
+			pathRoot: PurePosixPath | None = None,
+			logicalPathINFIX: str_nameDOTname | None = None,
+			filenameStem: str | None = None,
+			fileExtension: str | None = None,
+			) -> PurePosixPath:
+		if pathRoot is None:
+			pathRoot = self.pathPackage or PurePosixPath(Path.cwd())
+		if logicalPathINFIX:
+			whyIsThisStillAThing: list[str] = logicalPathINFIX.split('.')
+			pathRoot = pathRoot.joinpath(*whyIsThisStillAThing)
+		if filenameStem is None:
+			filenameStem = self.moduleIdentifier
+		if fileExtension is None:
+			fileExtension = self.fileExtension
+		filename: str = filenameStem + fileExtension
+		return pathRoot.joinpath(filename)
+
+	@property
+	def pathFilenameModule(self) -> PurePosixPath:
+		if self.pathModule is None:
+			return self._makePathFilename()
+		else:
+			return self._makePathFilename(pathRoot=self.pathModule, logicalPathINFIX=None)
+
+	def __post_init__(self):
+		pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(self.state.mapShape))
+
+		if self.moduleIdentifier is None: # pyright: ignore[reportUnnecessaryComparison]
+			self.moduleIdentifier = pathFilenameFoldsTotal.stem
+
+		if self.pathFilenameFoldsTotal is None: # pyright: ignore[reportUnnecessaryComparison]
+			self.pathFilenameFoldsTotal = pathFilenameFoldsTotal
+
+		if self.shatteredDataclass is None and self.logicalPathModuleDataclass and self.dataclassIdentifier and self.dataclassInstance: # pyright: ignore[reportUnnecessaryComparison]
+			self.shatteredDataclass = shatter_dataclassesDOTdataclass(self.logicalPathModuleDataclass, self.dataclassIdentifier, self.dataclassInstance)
+
+	# ========================================
+	# Fields you probably don't need =================================
+	# Dispatcher =================================
+	sourceDispatcherCallable: ast_Identifier = theNumbaFlow.callableDispatcher
+	dispatcherCallable: ast_Identifier = sourceDispatcherCallable
+	# Parallel counting =================================
+	sourceDataclassInstanceTaskDistribution: ast_Identifier = theNumbaFlow.dataclassInstanceTaskDistribution
+	sourceConcurrencyManagerNamespace: ast_Identifier = theNumbaFlow.concurrencyManagerNamespace
+	sourceConcurrencyManagerIdentifier: ast_Identifier = theNumbaFlow.concurrencyManagerIdentifier
+	dataclassInstanceTaskDistribution: ast_Identifier = sourceDataclassInstanceTaskDistribution
+	concurrencyManagerNamespace: ast_Identifier = sourceConcurrencyManagerNamespace
+	concurrencyManagerIdentifier: ast_Identifier = sourceConcurrencyManagerIdentifier