mapFolding 0.11.1__tar.gz → 0.11.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mapFolding
-Version: 0.11.1
+Version: 0.11.2
 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
@@ -67,12 +67,6 @@ Dynamic: license-file
 - You're interested in solving mathematical puzzles through code
 - You're learning about Numba and advanced Python optimization
 
-**This package is NOT for you if:**
-
-- You're looking for a general-purpose folding simulation tool
-- You need commercial-ready mapping software
-- You want simple visualization of folding patterns
-
 ## What Does This Package Actually Do?
 
 `mapFolding` solves a specific mathematical problem: counting the number of distinct ways to fold a rectangular map. While this may sound niche, it's a fascinating computational challenge that demonstrates:
@@ -87,7 +81,7 @@ The package has achieved new computational records, including first-ever calcula
 ```python
 # Compute the number of ways to fold a 5×5 grid:
 from mapFolding import oeisIDfor_n
-foldsTotal = oeisIDfor_n('A001418', 5)  # Returns 186,086,600
+foldsTotal = oeisIDfor_n('A001418', 5)
 ```
 
 ## Key Benefits for Computational Enthusiasts
@@ -178,4 +172,18 @@ If you've read this far and are intrigued by computational puzzles, algorithm op
 
 Whether you use it to solve map folding problems or to study its optimization techniques, `mapFolding` offers a unique window into advanced Python programming approaches.
 
+## My recovery
+
+[![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
+[![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)
+
+## How to code
+
+Coding One Step at a Time:
+
+0. WRITE CODE.
+1. Don't write stupid code that's hard to revise.
+2. Write good code.
+3. When revising, write better code.
+
 [![CC-BY-NC-4.0](https://github.com/hunterhogan/mapFolding/blob/main/CC-BY-NC-4.0.svg)](https://creativecommons.org/licenses/by-nc/4.0/)

{mapfolding-0.11.1 → mapfolding-0.11.2}/README.md

@@ -11,12 +11,6 @@
 - You're interested in solving mathematical puzzles through code
 - You're learning about Numba and advanced Python optimization
 
-**This package is NOT for you if:**
-
-- You're looking for a general-purpose folding simulation tool
-- You need commercial-ready mapping software
-- You want simple visualization of folding patterns
-
 ## What Does This Package Actually Do?
 
 `mapFolding` solves a specific mathematical problem: counting the number of distinct ways to fold a rectangular map. While this may sound niche, it's a fascinating computational challenge that demonstrates:
@@ -31,7 +25,7 @@ The package has achieved new computational records, including first-ever calcula
 ```python
 # Compute the number of ways to fold a 5×5 grid:
 from mapFolding import oeisIDfor_n
-foldsTotal = oeisIDfor_n('A001418', 5)  # Returns 186,086,600
+foldsTotal = oeisIDfor_n('A001418', 5)
 ```
 
 ## Key Benefits for Computational Enthusiasts
@@ -122,4 +116,18 @@ If you've read this far and are intrigued by computational puzzles, algorithm op
 
 Whether you use it to solve map folding problems or to study its optimization techniques, `mapFolding` offers a unique window into advanced Python programming approaches.
 
+## My recovery
+
+[![Static Badge](https://img.shields.io/badge/2011_August-Homeless_since-blue?style=flat)](https://HunterThinks.com/support)
+[![YouTube Channel Subscribers](https://img.shields.io/youtube/channel/subscribers/UC3Gx7kz61009NbhpRtPP7tw)](https://www.youtube.com/@HunterHogan)
+
+## How to code
+
+Coding One Step at a Time:
+
+0. WRITE CODE.
+1. Don't write stupid code that's hard to revise.
+2. Write good code.
+3. When revising, write better code.
+
 [![CC-BY-NC-4.0](https://github.com/hunterhogan/mapFolding/blob/main/CC-BY-NC-4.0.svg)](https://creativecommons.org/licenses/by-nc/4.0/)

mapfolding-0.11.2/mapFolding/__init__.py

@@ -0,0 +1,75 @@
+from typing import Any, TypeAlias
+import sys
+
+yourPythonIsOld: TypeAlias = Any
+# ruff: noqa: E402
+
+if sys.version_info >= (3, 11):
+	from typing import TypedDict as TypedDict
+	from typing import NotRequired as NotRequired
+else:
+	try:
+		from typing_extensions import TypedDict as TypedDict
+		from typing_extensions import NotRequired as NotRequired
+	except Exception:
+		TypedDict = dict[yourPythonIsOld, yourPythonIsOld]
+		from collections.abc import Iterable
+		NotRequired: TypeAlias = Iterable
+
+from mapFolding.datatypes import (
+	Array1DElephino as Array1DElephino,
+	Array1DFoldsTotal as Array1DFoldsTotal,
+	Array1DLeavesTotal as Array1DLeavesTotal,
+	Array3D as Array3D,
+	DatatypeElephino as DatatypeElephino,
+	DatatypeFoldsTotal as DatatypeFoldsTotal,
+	DatatypeLeavesTotal as DatatypeLeavesTotal,
+	NumPyElephino as NumPyElephino,
+	NumPyFoldsTotal as NumPyFoldsTotal,
+	NumPyIntegerType as NumPyIntegerType,
+	NumPyLeavesTotal as NumPyLeavesTotal,
+)
+
+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,
+	getPathRootJobDEFAULT as getPathRootJobDEFAULT,
+	saveFoldsTotal as saveFoldsTotal,
+	saveFoldsTotalFAILearly as saveFoldsTotalFAILearly,
+)
+
+from mapFolding.basecamp import countFolds as countFolds
+
+from mapFolding.oeis import (
+	clearOEIScache as clearOEIScache,
+	getFoldsTotalKnown as getFoldsTotalKnown,
+	getOEISids as getOEISids,
+	OEIS_for_n as OEIS_for_n,
+	oeisIDfor_n as oeisIDfor_n,
+)

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

@@ -11,9 +11,7 @@ appropriate algorithm implementation, and optional persistence of results.
 
 from collections.abc import Sequence
 from mapFolding import (
-	ComputationState,
 	getPathFilenameFoldsTotal,
-	outfitCountFolds,
 	saveFoldsTotal,
 	saveFoldsTotalFAILearly,
 	setProcessorLimit,
@@ -163,20 +161,25 @@ def countFolds(listDimensions: Sequence[int] | None = None
 		from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
 		mapFoldingState = initializeGroupsOfFolds(mapFoldingState)
 
-		from mapFolding.syntheticModules.dataPacking import doTheNeedful
-		mapFoldingState = doTheNeedful(mapFoldingState)
+		from mapFolding.syntheticModules.dataPacking import sequential
+		mapFoldingState = sequential(mapFoldingState)
 
 		foldsTotal = mapFoldingState.foldsTotal
 
-	# NOTE treat this as a default?
-	# flow based on `The` and `ComputationState` ====================================
+	elif taskDivisions > 1:
+		from mapFolding.dataBaskets import ParallelMapFoldingState
+		parallelMapFoldingState: ParallelMapFoldingState = ParallelMapFoldingState(mapShape, taskDivisions=taskDivisions)
+
+		from mapFolding.syntheticModules.countParallel import doTheNeedful
+		foldsTotal, listStatesParallel = doTheNeedful(parallelMapFoldingState, concurrencyLimit)
 
 	else:
-		computationStateInitialized: ComputationState = outfitCountFolds(mapShape, computationDivisions, concurrencyLimit)
-		computationStateComplete: ComputationState = The.dispatcher(computationStateInitialized)
+		from mapFolding.dataBaskets import MapFoldingState
+		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
-		computationStateComplete.getFoldsTotal()
-		foldsTotal = computationStateComplete.foldsTotal
+		from mapFolding.syntheticModules.daoOfMapFolding import doTheNeedful
+		mapFoldingState = doTheNeedful(mapFoldingState)
+		foldsTotal = mapFoldingState.foldsTotal
 
 	# Follow memorialization instructions ===========================================
 

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

@@ -18,12 +18,13 @@ These utilities form a stable internal API that other modules depend on, particu
 theDao (core algorithm), and the synthetic module generators that produce optimized implementations.
 """
 from collections.abc import Sequence
-from mapFolding import ComputationState, NumPyIntegerType
+from mapFolding import Array1DElephino, Array1DFoldsTotal, Array1DLeavesTotal, Array3D, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal, NumPyIntegerType
 from numpy import dtype as numpy_dtype, int64 as numpy_int64, ndarray
 from sys import maxsize as sysMaxsize
 from typing import Any
 from Z0Z_tools import defineConcurrencyLimit, intInnit, oopsieKwargsie
 import numpy
+import dataclasses
 
 def getLeavesTotal(mapShape: tuple[int, ...]) -> int:
 	"""
@@ -59,7 +60,6 @@ def getTaskDivisions(computationDivisions: int | str | None, concurrencyLimit: i
 	"""
 	Determines whether to divide the computation into tasks and how many divisions.
 
-
 	Parameters
 	----------
 	computationDivisions: None
@@ -208,6 +208,117 @@ 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.

{mapfolding-0.11.1 → mapfolding-0.11.2}/mapFolding/dataBaskets.py

@@ -1,5 +1,14 @@
-from mapFolding.beDRY import getConnectionGraph, getLeavesTotal, makeDataContainer
-from mapFolding.datatypes import Array3D, Array1DElephino, Array1DLeavesTotal, DatatypeElephino, DatatypeFoldsTotal, DatatypeLeavesTotal
+from mapFolding import (
+	Array1DElephino,
+	Array1DLeavesTotal,
+	Array3D,
+	DatatypeElephino,
+	DatatypeFoldsTotal,
+	DatatypeLeavesTotal,
+	getConnectionGraph,
+	getLeavesTotal,
+	makeDataContainer,
+)
 import dataclasses
 
 @dataclasses.dataclass
@@ -48,6 +57,19 @@ class MapFoldingState:
 		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 ParallelMapFoldingState(MapFoldingState):
+	taskDivisions: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+	"""Number of tasks into which to divide the computation. If the value is greater than `leavesTotal`, the computation will be wrong. Default is `leavesTotal`."""
+
+	taskIndex: DatatypeLeavesTotal = DatatypeLeavesTotal(0)
+	"""Index of the current task when using task divisions."""
+
+	def __post_init__(self) -> None:
+		super().__post_init__()
+		if self.taskDivisions == 0:
+			self.taskDivisions = DatatypeLeavesTotal(int(self.leavesTotal))
+
 @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]

mapfolding-0.11.1/mapFolding/toolboxFilesystem.py → mapfolding-0.11.2/mapFolding/filesystemToolkit.py

@@ -21,7 +21,7 @@ The functions here adhere to a consistent approach to path handling:
 - Progressive fallback strategies for saving critical computation results.
 - Preemptive filesystem validation to detect issues before computation begins.
 """
-from mapFolding import The
+from mapFolding import packageSettings
 from os import PathLike
 from pathlib import Path, PurePath
 from sys import modules as sysModules
@@ -101,9 +101,9 @@ def getPathRootJobDEFAULT() -> Path:
 		- For Google Colab, uses a specific path in Google Drive.
 		- Creates the directory if it doesn't exist.
 	"""
-	pathJobDEFAULT = Path(platformdirs.user_data_dir(appname=The.packageName, appauthor=False, ensure_exists=True))
+	pathJobDEFAULT = Path(platformdirs.user_data_dir(appname=packageSettings.packageName, appauthor=False, ensure_exists=True))
 	if 'google.colab' in sysModules:
-		pathJobDEFAULT = Path("/content/drive/MyDrive") / The.packageName
+		pathJobDEFAULT = Path("/content/drive/MyDrive") / packageSettings.packageName
 	pathJobDEFAULT.mkdir(parents=True, exist_ok=True)
 	return pathJobDEFAULT
 

mapfolding-0.11.2/mapFolding/infoBooth.py

@@ -0,0 +1,96 @@
+from collections.abc import Callable
+from importlib import import_module as importlib_import_module
+from mapFolding import ComputationState, PackageSettings
+from types import ModuleType
+import dataclasses
+
+@dataclasses.dataclass
+class PackageInformation(PackageSettings):
+	"""
+	In _all_ of the root directory and "syntheticModules", the _only_ `PackageInformation` that are used are:
+		The.concurrencyPackage
+		The.dispatcher
+	"""
+
+	logicalPathModuleDispatcher: str | None = None
+	"""Logical import path to the module containing the dispatcher function."""
+
+	callableDispatcher: str | None = None
+	"""Name of the function within the dispatcher module that will be called."""
+
+	concurrencyPackage: str | None = None
+	"""Package to use for concurrent execution (e.g., 'multiprocessing', 'numba')."""
+
+	# "Evaluate When Packaging" and "Evaluate When Installing" https://github.com/hunterhogan/mapFolding/issues/18
+	dataclassIdentifier: str = dataclasses.field(default='ComputationState', metadata={'evaluateWhen': 'packaging'})
+	"""Name of the dataclass used to track computation state."""
+
+	dataclassInstance: str = dataclasses.field(default='state', metadata={'evaluateWhen': 'packaging'})
+	"""Default variable name for instances of the computation state dataclass."""
+
+	dataclassInstanceTaskDistributionSuffix: str = dataclasses.field(default='Parallel', metadata={'evaluateWhen': 'packaging'})
+	"""Suffix added to dataclassInstance for parallel task distribution."""
+
+	dataclassModule: str = dataclasses.field(default='beDRY', metadata={'evaluateWhen': 'packaging'})
+	"""Module containing the computation state dataclass definition."""
+
+	datatypePackage: str = dataclasses.field(default='numpy', metadata={'evaluateWhen': 'packaging'})
+	"""Package providing the numeric data types used in computation."""
+
+	sourceAlgorithm: str = dataclasses.field(default='theDao', metadata={'evaluateWhen': 'packaging'})
+	"""Module containing the reference implementation of the algorithm."""
+
+	sourceCallableDispatcher: str = dataclasses.field(default='doTheNeedful', metadata={'evaluateWhen': 'packaging'})
+	"""Name of the function that dispatches computation in the source algorithm."""
+
+	sourceCallableInitialize: str = dataclasses.field(default='countInitialize', metadata={'evaluateWhen': 'packaging'})
+	"""Name of the function that initializes computation in the source algorithm."""
+
+	sourceCallableParallel: str = dataclasses.field(default='countParallel', metadata={'evaluateWhen': 'packaging'})
+	"""Name of the function that performs parallel computation in the source algorithm."""
+
+	sourceCallableSequential: str = dataclasses.field(default='countSequential', metadata={'evaluateWhen': 'packaging'})
+	"""Name of the function that performs sequential computation in the source algorithm."""
+
+	sourceConcurrencyManagerIdentifier: str = dataclasses.field(default='submit', metadata={'evaluateWhen': 'packaging'})
+	"""Method name used to submit tasks to the concurrency manager."""
+
+	sourceConcurrencyManagerNamespace: str = dataclasses.field(default='concurrencyManager', metadata={'evaluateWhen': 'packaging'})
+	"""Variable name used for the concurrency manager instance."""
+
+	sourceConcurrencyPackage: str = dataclasses.field(default='multiprocessing', metadata={'evaluateWhen': 'packaging'})
+	"""Default package used for concurrency in the source algorithm."""
+
+	dataclassInstanceTaskDistribution: str = dataclasses.field(default=None, metadata={'evaluateWhen': 'packaging'}) # pyright: ignore[reportAssignmentType]
+	"""Variable name for the parallel distribution instance of the computation state."""
+
+	logicalPathModuleDataclass: str = dataclasses.field(default=None, metadata={'evaluateWhen': 'packaging'}) # pyright: ignore[reportAssignmentType]
+	"""Fully qualified import path to the module containing the computation state dataclass."""
+
+	logicalPathModuleSourceAlgorithm: str = dataclasses.field(default=None, metadata={'evaluateWhen': 'packaging'}) # pyright: ignore[reportAssignmentType]
+	"""Fully qualified import path to the module containing the source algorithm."""
+
+	@property
+	def dispatcher(self) -> Callable[['ComputationState'], 'ComputationState']:
+		""" _The_ callable that connects `countFolds` to the logic that does the work."""
+		logicalPath: str = self.logicalPathModuleDispatcher or self.logicalPathModuleSourceAlgorithm
+		identifier: str = self.callableDispatcher or self.sourceCallableDispatcher
+		moduleImported: ModuleType = importlib_import_module(logicalPath)
+		return getattr(moduleImported, identifier)
+
+	def __post_init__(self) -> None:
+		if self.dataclassInstanceTaskDistribution is None: # pyright: ignore[reportUnnecessaryComparison]
+			self.dataclassInstanceTaskDistribution = self.dataclassInstance + self.dataclassInstanceTaskDistributionSuffix
+
+		if self.logicalPathModuleDataclass is None: # pyright: ignore[reportUnnecessaryComparison]
+			self.logicalPathModuleDataclass = '.'.join([self.packageName, self.dataclassModule])
+		if self.logicalPathModuleSourceAlgorithm is None: # pyright: ignore[reportUnnecessaryComparison]
+			self.logicalPathModuleSourceAlgorithm = '.'.join([self.packageName, self.sourceAlgorithm])
+
+class raiseIfNoneGitHubIssueNumber3(Exception): pass
+
+logicalPathModuleDispatcherHARDCODED: str = 'mapFolding.syntheticModules.numbaCount'
+callableDispatcherHARDCODED: str = 'doTheNeedful'
+concurrencyPackageHARDCODED = 'multiprocessing'
+
+The = PackageInformation(logicalPathModuleDispatcher=logicalPathModuleDispatcherHARDCODED, callableDispatcher=callableDispatcherHARDCODED, concurrencyPackage=concurrencyPackageHARDCODED)

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

@@ -20,9 +20,10 @@ 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, TypedDict, writeStringToHere
+from mapFolding import countFolds, packageSettings, TypedDict
 from pathlib import Path
 from typing import Any, Final
+from Z0Z_tools import writeStringToHere
 import argparse
 import random
 import sys
@@ -33,7 +34,7 @@ import warnings
 
 cacheDays = 30
 
-pathCache: Path = The.pathPackage / ".cache"
+pathCache: Path = packageSettings.pathPackage / ".cache"
 
 class SettingsOEIS(TypedDict):
 	description: str

{mapfolding-0.11.1 → mapfolding-0.11.2}/mapFolding/someAssemblyRequired/RecipeJob.py

@@ -1,9 +1,8 @@
+from mapFolding import ComputationState, getPathFilenameFoldsTotal, getPathRootJobDEFAULT, MapFoldingState
+from mapFolding import DatatypeElephino as TheDatatypeElephino, DatatypeFoldsTotal as TheDatatypeFoldsTotal, DatatypeLeavesTotal as TheDatatypeLeavesTotal
 from mapFolding.someAssemblyRequired import ShatteredDataclass, ast_Identifier, parseLogicalPath2astModule, parsePathFilename2astModule, str_nameDOTname
-from mapFolding.someAssemblyRequired.toolboxNumba import theNumbaFlow
+from mapFolding.someAssemblyRequired.toolkitNumba 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
-from mapFolding.dataBaskets import MapFoldingState
 from pathlib import Path, PurePosixPath
 from typing import TypeAlias
 import dataclasses