mapFolding 0.11.2__tar.gz → 0.11.4__tar.gz

{mapfolding-0.11.2 → mapfolding-0.11.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.11.2
+Version: 0.11.4
 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
@@ -33,8 +33,6 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: astToolkit
 Requires-Dist: autoflake
-Requires-Dist: cytoolz
-Requires-Dist: more_itertools
 Requires-Dist: numba_progress
 Requires-Dist: numba
 Requires-Dist: numpy
@@ -42,7 +40,6 @@ 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.11.2 → mapfolding-0.11.4}/mapFolding/__init__.py

@@ -33,29 +33,16 @@ from mapFolding.datatypes import (
 from mapFolding.theSSOT import PackageSettings as PackageSettings, packageSettings as packageSettings
 
 from mapFolding.beDRY import (
-	ComputationState as ComputationState,
 	getConnectionGraph as getConnectionGraph,
 	getLeavesTotal as getLeavesTotal,
 	getTaskDivisions as getTaskDivisions,
 	makeDataContainer as makeDataContainer,
-	outfitCountFolds as outfitCountFolds,
 	setProcessorLimit as setProcessorLimit,
 	validateListDimensions as validateListDimensions,
 )
 
 from mapFolding.dataBaskets import MapFoldingState as MapFoldingState
 
-from mapFolding.infoBooth import (
-	PackageInformation as PackageInformation,
-	raiseIfNoneGitHubIssueNumber3 as raiseIfNoneGitHubIssueNumber3,
-	The as The,
-)
-
-from mapFolding.theDao import (
-	countInitialize as countInitialize,
-	doTheNeedful as doTheNeedful,
-)
-
 from mapFolding.filesystemToolkit import (
 	getFilenameFoldsTotal as getFilenameFoldsTotal,
 	getPathFilenameFoldsTotal as getPathFilenameFoldsTotal,

{mapfolding-0.11.2 → mapfolding-0.11.4}/mapFolding/basecamp.py

@@ -12,10 +12,10 @@ appropriate algorithm implementation, and optional persistence of results.
 from collections.abc import Sequence
 from mapFolding import (
 	getPathFilenameFoldsTotal,
+	packageSettings,
 	saveFoldsTotal,
 	saveFoldsTotalFAILearly,
 	setProcessorLimit,
-	The,
 	validateListDimensions,
 )
 from os import PathLike
@@ -102,8 +102,7 @@ def countFolds(listDimensions: Sequence[int] | None = None
 	# task division instructions ===============================================
 
 	if computationDivisions:
-		# NOTE `The.concurrencyPackage`
-		concurrencyLimit: int = setProcessorLimit(CPUlimit, The.concurrencyPackage)
+		concurrencyLimit: int = setProcessorLimit(CPUlimit, packageSettings.concurrencyPackage)
 		from mapFolding.beDRY import getLeavesTotal, getTaskDivisions
 		leavesTotal: int = getLeavesTotal(mapShape)
 		taskDivisions = getTaskDivisions(computationDivisions, concurrencyLimit, leavesTotal)

{mapfolding-0.11.2 → mapfolding-0.11.4}/mapFolding/beDRY.py

@@ -208,150 +208,6 @@ def makeDataContainer(shape: int | tuple[int, ...], datatype: type[NumPyIntegerT
 	"""
 	return numpy.zeros(shape, dtype=datatype)
 
-
-@dataclasses.dataclass
-class ComputationState:
-	"""
-	Represents the complete state of a map folding computation.
-
-	This dataclass encapsulates all the information required to compute the number of possible ways to fold a map,
-	including the map dimensions, leaf connections, computation progress, and fold counting. It serves as the central
-	data structure that flows through the entire computational algorithm.
-
-	Fields are categorized into:
-	1. Input parameters (`mapShape`, `leavesTotal`, etc.).
-	2. Core computational structures (`connectionGraph`, etc.).
-	3. Tracking variables for the folding algorithm state.
-	4. Result accumulation fields (`foldsTotal`, `groupsOfFolds`).
-	"""
-	# NOTE Python is anti-DRY, again, `DatatypeLeavesTotal` metadata needs to match the type
-	mapShape: tuple[DatatypeLeavesTotal, ...] = dataclasses.field(init=True, metadata={'elementConstructor': 'DatatypeLeavesTotal'})
-	"""Dimensions of the map to be folded, as a tuple of integers."""
-
-	leavesTotal: DatatypeLeavesTotal
-	"""Total number of leaves (unit squares) in the map, equal to the product of all dimensions."""
-
-	taskDivisions: DatatypeLeavesTotal
-	"""Number of parallel tasks to divide the computation into. Zero means sequential computation."""
-
-	concurrencyLimit: DatatypeElephino
-	"""Maximum number of concurrent processes to use during computation."""
-
-	connectionGraph: Array3D = dataclasses.field(init=False, metadata={'dtype': Array3D.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
-	"""3D array encoding the connections between leaves in all dimensions."""
-
-	dimensionsTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
-	"""Total number of dimensions in the map shape."""
-
-	# I am using `dataclasses.field` metadata and `typeAlias.__args__[1].__args__[0]` to make the code more DRY. https://github.com/hunterhogan/mapFolding/issues/9
-	countDimensionsGapped: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""Tracks how many dimensions are gapped for each leaf."""
-
-	dimensionsUnconstrained: DatatypeLeavesTotal = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""Number of dimensions that are not constrained in the current folding state."""
-
-	gapRangeStart: Array1DElephino = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DElephino.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""Starting index for the gap range for each leaf."""
-
-	gapsWhere: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""Tracks where gaps occur in the folding pattern."""
-
-	leafAbove: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""For each leaf, stores the index of the leaf above it in the folding pattern."""
-
-	leafBelow: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""For each leaf, stores the index of the leaf below it in the folding pattern."""
-
-	foldGroups: Array1DFoldsTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DFoldsTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
-	"""Accumulator for fold groups across parallel tasks."""
-
-	foldsTotal: DatatypeFoldsTotal = DatatypeFoldsTotal(0)
-	"""The final computed total number of distinct folding patterns."""
-
-	gap1ndex: DatatypeElephino = DatatypeElephino(0)
-	"""Current index into gaps array during algorithm execution."""
-
-	gap1ndexCeiling: DatatypeElephino = DatatypeElephino(0)
-	"""Upper limit for gap index during the current algorithm phase."""
-
-	groupsOfFolds: DatatypeFoldsTotal = dataclasses.field(default=DatatypeFoldsTotal(0), metadata={'theCountingIdentifier': True})
-	"""Accumulator for the number of fold groups found during computation."""
-
-	indexDimension: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
-	"""Current dimension being processed during algorithm execution."""
-
-	indexLeaf: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
-	"""Current leaf index during iteration."""
-
-	indexMiniGap: DatatypeElephino = DatatypeElephino(0)
-	"""Index used when filtering common gaps."""
-
-	leaf1ndex: DatatypeLeavesTotal = DatatypeLeavesTotal(1)
-	"""Active leaf being processed in the folding algorithm. Starts at 1, not 0."""
-
-	leafConnectee: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
-	"""Leaf that is being connected to the active leaf."""
-
-	taskIndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
-	"""Index of the current parallel task when using task divisions."""
-
-	def __post_init__(self) -> None:
-		from mapFolding.beDRY import getConnectionGraph, makeDataContainer
-		self.dimensionsTotal = DatatypeLeavesTotal(len(self.mapShape))
-		leavesTotalAsInt = int(self.leavesTotal)
-		self.connectionGraph = getConnectionGraph(self.mapShape, leavesTotalAsInt, self.__dataclass_fields__['connectionGraph'].metadata['dtype'])
-
-		if self.dimensionsUnconstrained is None: self.dimensionsUnconstrained = DatatypeLeavesTotal(int(self.dimensionsTotal)) # pyright: ignore[reportUnnecessaryComparison]
-
-		if self.foldGroups is None: # pyright: ignore[reportUnnecessaryComparison]
-			self.foldGroups = makeDataContainer(max(2, int(self.taskDivisions) + 1), self.__dataclass_fields__['foldGroups'].metadata['dtype'])
-			self.foldGroups[-1] = self.leavesTotal
-
-		# Dataclasses, Default factories, and arguments in `ComputationState` https://github.com/hunterhogan/mapFolding/issues/12
-		if self.gapsWhere is None: self.gapsWhere = makeDataContainer(leavesTotalAsInt * leavesTotalAsInt + 1, self.__dataclass_fields__['gapsWhere'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
-
-		if self.countDimensionsGapped is None: self.countDimensionsGapped = makeDataContainer(leavesTotalAsInt + 1, self.__dataclass_fields__['countDimensionsGapped'].metadata['dtype']) # pyright: ignore[reportUnnecessaryComparison]
-		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]
-
-	# Automatic, or not, calculation in dataclass `ComputationState` https://github.com/hunterhogan/mapFolding/issues/14
-	def getFoldsTotal(self) -> None:
-		self.foldsTotal = DatatypeFoldsTotal(self.foldGroups[0:-1].sum() * self.leavesTotal)
-
-def outfitCountFolds(mapShape: tuple[int, ...], computationDivisions: int | str | None = None, concurrencyLimit: int = 1) -> ComputationState:
-	"""
-	Initialize a `ComputationState` with validated parameters for map folding calculation.
-
-	This function serves as the central initialization point for creating a properly configured `ComputationState`
-	object, ensuring consistent calculation of the fundamental parameters (`leavesTotal` and `taskDivisions`) across the
-	entire package.
-
-	Parameters
-	----------
-	mapShape
-		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
-		`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.
-
-	Returns
-	-------
-	computationStateInitialized
-		A fully initialized `ComputationState` object that's ready for computation.
-
-	Notes
-	-----
-	This function maintains the Single Source of Truth principle for `leavesTotal` and `taskDivisions` calculation,
-	ensuring these values are derived consistently throughout the package.
-	"""
-	leavesTotal = getLeavesTotal(mapShape)
-	taskDivisions = getTaskDivisions(computationDivisions, concurrencyLimit, leavesTotal)
-	computationStateInitialized = ComputationState(mapShape, leavesTotal, taskDivisions, concurrencyLimit)
-	return computationStateInitialized
-
 def setProcessorLimit(CPUlimit: Any | None, concurrencyPackage: str | None = None) -> int:
 	"""
 	Whether and how to limit the CPU usage.
@@ -392,7 +248,8 @@ def setProcessorLimit(CPUlimit: Any | None, concurrencyPackage: str | None = Non
 
 	match concurrencyPackage:
 		case 'multiprocessing' | None:
-			# When to use multiprocessing.set_start_method https://github.com/hunterhogan/mapFolding/issues/6
+			# When to use multiprocessing.set_start_method
+			# https://github.com/hunterhogan/mapFolding/issues/6
 			concurrencyLimit: int = defineConcurrencyLimit(CPUlimit)
 		case 'numba':
 			from numba import get_num_threads, set_num_threads

{mapfolding-0.11.2 → mapfolding-0.11.4}/mapFolding/datatypes.py

@@ -1,9 +1,6 @@
 from numpy import dtype, uint8 as numpy_uint8, uint16 as numpy_uint16, uint64 as numpy_uint64, integer, ndarray
 from typing import Any, TypeAlias, TypeVar
 
-# =============================================================================
-# Flexible Data Structure System Needs Enhanced Paradigm https://github.com/hunterhogan/mapFolding/issues/9
-
 NumPyIntegerType = TypeVar('NumPyIntegerType', bound=integer[Any], covariant=True)
 
 DatatypeLeavesTotal: TypeAlias = int

{mapfolding-0.11.2 → mapfolding-0.11.4}/mapFolding/oeis.py

@@ -144,9 +144,6 @@ def _parseBFileOEIS(OEISbFile: str, oeisID: str) -> dict[int, int]:
 		invalid.
 	"""
 	bFileLines: list[str] = OEISbFile.strip().splitlines()
-	# if not bFileLines.pop(0).startswith(f"# {oeisID}"):
-	# 	warnings.warn(f"Content does not match sequence {oeisID}")
-	# 	return {-1: -1}
 
 	OEISsequence: dict[int, int] = {}
 	for line in bFileLines:

mapfolding-0.11.4/mapFolding/someAssemblyRequired/RecipeJob.py

@@ -0,0 +1,89 @@
+from astToolkit import parseLogicalPath2astModule, str_nameDOTname
+from mapFolding import getPathFilenameFoldsTotal, getPathRootJobDEFAULT, MapFoldingState, packageSettings
+from mapFolding import DatatypeElephino as TheDatatypeElephino, DatatypeFoldsTotal as TheDatatypeFoldsTotal, DatatypeLeavesTotal as TheDatatypeLeavesTotal
+from mapFolding.someAssemblyRequired import dataclassInstanceIdentifierHardcoded, ShatteredDataclass
+from mapFolding.someAssemblyRequired.transformationTools import shatter_dataclassesDOTdataclass
+from pathlib import Path, PurePosixPath
+from typing import TypeAlias
+import dataclasses
+
+@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: str = 'count'
+
+	sourceLogicalPathModuleDataclass: str_nameDOTname = 'mapFolding.dataBaskets'
+	sourceDataclassIdentifier: str = 'MapFoldingState'
+	sourceDataclassInstance: str = dataclassInstanceIdentifierHardcoded
+
+	sourcePathPackage: PurePosixPath | None = PurePosixPath(packageSettings.pathPackage)
+	sourcePackageIdentifier: str | None = packageSettings.packageName
+
+	# ========================================
+	# Filesystem (names of physical objects)
+	pathPackage: PurePosixPath | None = None
+	pathModule: PurePosixPath | None = PurePosixPath(getPathRootJobDEFAULT())
+	""" `pathModule` will override `pathPackage` and `logicalPathRoot`."""
+	fileExtension: str = packageSettings.fileExtension
+	pathFilenameFoldsTotal: PurePosixPath = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
+
+	# ========================================
+	# Logical identifiers (as opposed to physical identifiers)
+	packageIdentifier: str | None = None
+	logicalPathRoot: str_nameDOTname | None = None
+	""" `logicalPathRoot` likely corresponds to a physical filesystem directory."""
+	moduleIdentifier: str = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
+	countCallable: str = sourceCountCallable
+	dataclassIdentifier: str | None = sourceDataclassIdentifier
+	dataclassInstance: str | 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)