mapFolding 0.11.1__py3-none-any.whl → 0.11.2__py3-none-any.whl

mapFolding/__init__.py

@@ -1,49 +1,3 @@
-"""
-Map folding enumeration and counting algorithms with advanced optimization capabilities.
-
-This package implements algorithms to count and enumerate the distinct ways a rectangular map can be folded, based on
-the mathematical problem described in Lunnon's 1971 paper. It provides multiple layers of functionality, from high-level
-user interfaces to sophisticated algorithmic optimizations and code transformation tools.
-
-Core modules:
-- basecamp: Public API with simplified interfaces for end users
-- theDao: Core computational algorithm using a functional state-transformation approach
-- beDRY: Core utility functions implementing consistent data handling, validation, and resource management across the
-	package's computational assembly-line
-- theSSOT: Single Source of Truth for configuration, types, and state management
-- toolboxFilesystem: Cross-platform file management services for storing and retrieving computation results with robust
-	error handling and fallback mechanisms
-- oeis: Interface to the Online Encyclopedia of Integer Sequences for known results
-
-Extended functionality:
-- someAssemblyRequired: Code transformation framework that optimizes the core algorithm through AST manipulation,
-	dataclass transformation, and compilation techniques
-	- The system converts readable code into high-performance implementations through a systematic analysis and
-		transformation assembly line
-	- Provides tools to "shatter" complex dataclasses into primitive components, enabling compatibility with Numba and
-		other optimization frameworks
-	- Creates specialized implementations tailored for specific input parameters
-
-Testing and extension:
-- tests: Comprehensive test suite designed for both verification and extension
-	- Provides fixtures and utilities that simplify testing of custom implementations
-	- Enables users to validate their own recipes and job configurations with minimal code
-	- Offers standardized testing patterns that maintain consistency across the codebase
-	- See tests/__init__.py for detailed documentation on extending the test suite
-
-Special directories:
-- .cache/: Stores cached data from external sources like OEIS to improve performance
-- syntheticModules/: Contains dynamically generated, optimized implementations of the core algorithm created by the code
-transformation framework
-- reference/: Historical implementations and educational resources for algorithm exploration
-	- reference/jobsCompleted/: Contains successful computations for previously unknown values, including first-ever
-		calculations for 2x19 and 2x20 maps (OEIS A001415)
-
-This package balances algorithm readability and understandability with high-performance computation capabilities,
-allowing users to compute map folding totals for larger dimensions than previously feasible while also providing a
-foundation for exploring advanced code transformation techniques.
-"""
-
 from typing import Any, TypeAlias
 import sys
 
@@ -76,8 +30,23 @@ from mapFolding.datatypes import (
 	NumPyLeavesTotal as NumPyLeavesTotal,
 )
 
-from mapFolding.theSSOT 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,
 )
@@ -87,23 +56,14 @@ from mapFolding.theDao import (
 	doTheNeedful as doTheNeedful,
 )
 
-from mapFolding.beDRY import (
-	getLeavesTotal as getLeavesTotal,
-	getTaskDivisions as getTaskDivisions,
-	outfitCountFolds as outfitCountFolds,
-	setProcessorLimit as setProcessorLimit,
-	validateListDimensions as validateListDimensions,
-)
-
-from mapFolding.toolboxFilesystem import (
+from mapFolding.filesystemToolkit import (
+	getFilenameFoldsTotal as getFilenameFoldsTotal,
 	getPathFilenameFoldsTotal as getPathFilenameFoldsTotal,
 	getPathRootJobDEFAULT as getPathRootJobDEFAULT,
 	saveFoldsTotal as saveFoldsTotal,
 	saveFoldsTotalFAILearly as saveFoldsTotalFAILearly,
 )
 
-from Z0Z_tools import writeStringToHere as writeStringToHere
-
 from mapFolding.basecamp import countFolds as countFolds
 
 from mapFolding.oeis import (

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/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/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/{toolboxFilesystem.py → 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/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/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/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