mapFolding 0.11.1__py3-none-any.whl → 0.11.3__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,34 +30,27 @@ from mapFolding.datatypes import (
 	NumPyLeavesTotal as NumPyLeavesTotal,
 )
 
-from mapFolding.theSSOT import (
-	ComputationState as ComputationState,
-	raiseIfNoneGitHubIssueNumber3 as raiseIfNoneGitHubIssueNumber3,
-	The as The,
-)
-
-from mapFolding.theDao import (
-	countInitialize as countInitialize,
-	doTheNeedful as doTheNeedful,
-)
+from mapFolding.theSSOT import PackageSettings as PackageSettings, packageSettings as packageSettings
 
 from mapFolding.beDRY import (
+	getConnectionGraph as getConnectionGraph,
 	getLeavesTotal as getLeavesTotal,
 	getTaskDivisions as getTaskDivisions,
-	outfitCountFolds as outfitCountFolds,
+	makeDataContainer as makeDataContainer,
 	setProcessorLimit as setProcessorLimit,
 	validateListDimensions as validateListDimensions,
 )
 
-from mapFolding.toolboxFilesystem import (
+from mapFolding.dataBaskets import MapFoldingState as MapFoldingState
+
+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,13 +11,11 @@ appropriate algorithm implementation, and optional persistence of results.
 
 from collections.abc import Sequence
 from mapFolding import (
-	ComputationState,
 	getPathFilenameFoldsTotal,
-	outfitCountFolds,
+	packageSettings,
 	saveFoldsTotal,
 	saveFoldsTotalFAILearly,
 	setProcessorLimit,
-	The,
 	validateListDimensions,
 )
 from os import PathLike
@@ -104,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)
@@ -163,20 +160,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,39 +208,6 @@ def makeDataContainer(shape: int | tuple[int, ...], datatype: type[NumPyIntegerT
 	"""
 	return numpy.zeros(shape, dtype=datatype)
 
-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.
@@ -281,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/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/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/{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/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
@@ -143,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/someAssemblyRequired/RecipeJob.py

@@ -1,107 +1,12 @@
-from mapFolding.someAssemblyRequired import ShatteredDataclass, ast_Identifier, parseLogicalPath2astModule, parsePathFilename2astModule, str_nameDOTname
-from mapFolding.someAssemblyRequired.toolboxNumba import theNumbaFlow
+from astToolkit import ast_Identifier, parseLogicalPath2astModule, str_nameDOTname
+from mapFolding import getPathFilenameFoldsTotal, getPathRootJobDEFAULT, MapFoldingState
+from mapFolding import DatatypeElephino as TheDatatypeElephino, DatatypeFoldsTotal as TheDatatypeFoldsTotal, DatatypeLeavesTotal as TheDatatypeLeavesTotal
+from mapFolding.someAssemblyRequired import ShatteredDataclass, packageInformation
 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
 
-@dataclasses.dataclass
-class RecipeJob:
-	state: ComputationState
-	# TODO create function to calculate `foldsTotalEstimated`
-	foldsTotalEstimated: int = 0
-	shatteredDataclass: ShatteredDataclass = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
-
-	# ========================================
-	# Source
-	source_astModule = parsePathFilename2astModule(theNumbaFlow.pathFilenameSequential)
-	sourceCountCallable: ast_Identifier = theNumbaFlow.callableSequential
-
-	sourceLogicalPathModuleDataclass: str_nameDOTname = theNumbaFlow.logicalPathModuleDataclass
-	sourceDataclassIdentifier: ast_Identifier = theNumbaFlow.dataclassIdentifier
-	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
-
 @dataclasses.dataclass
 class RecipeJobTheorem2Numba:
 	state: MapFoldingState
@@ -116,17 +21,17 @@ class RecipeJobTheorem2Numba:
 
 	sourceLogicalPathModuleDataclass: str_nameDOTname = 'mapFolding.dataBaskets'
 	sourceDataclassIdentifier: ast_Identifier = 'MapFoldingState'
-	sourceDataclassInstance: ast_Identifier = theNumbaFlow.dataclassInstance
+	sourceDataclassInstance: ast_Identifier = packageInformation.dataclassInstance
 
-	sourcePathPackage: PurePosixPath | None = theNumbaFlow.pathPackage
-	sourcePackageIdentifier: ast_Identifier | None = theNumbaFlow.packageIdentifier
+	sourcePathPackage: PurePosixPath | None = PurePosixPath(packageInformation.pathPackage)
+	sourcePackageIdentifier: ast_Identifier | None = packageInformation.packageName
 
 	# ========================================
 	# Filesystem (names of physical objects)
 	pathPackage: PurePosixPath | None = None
 	pathModule: PurePosixPath | None = PurePosixPath(getPathRootJobDEFAULT())
 	""" `pathModule` will override `pathPackage` and `logicalPathRoot`."""
-	fileExtension: str = theNumbaFlow.fileExtension
+	fileExtension: str = packageInformation.fileExtension
 	pathFilenameFoldsTotal: PurePosixPath = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
 
 	# ========================================
@@ -182,16 +87,3 @@ class RecipeJobTheorem2Numba:
 
 		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