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

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/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/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/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/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/someAssemblyRequired/RecipeJob.py

@@ -1,106 +1,12 @@
-from mapFolding import ComputationState, getPathFilenameFoldsTotal, getPathRootJobDEFAULT, MapFoldingState
+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 ShatteredDataclass, ast_Identifier, parseLogicalPath2astModule, parsePathFilename2astModule, str_nameDOTname
-from mapFolding.someAssemblyRequired.toolkitNumba import theNumbaFlow
+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 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
@@ -111,32 +17,32 @@ class RecipeJobTheorem2Numba:
 	# ========================================
 	# Source
 	source_astModule = parseLogicalPath2astModule('mapFolding.syntheticModules.theorem2Numba')
-	sourceCountCallable: ast_Identifier = 'count'
+	sourceCountCallable: str = 'count'
 
 	sourceLogicalPathModuleDataclass: str_nameDOTname = 'mapFolding.dataBaskets'
-	sourceDataclassIdentifier: ast_Identifier = 'MapFoldingState'
-	sourceDataclassInstance: ast_Identifier = theNumbaFlow.dataclassInstance
+	sourceDataclassIdentifier: str = 'MapFoldingState'
+	sourceDataclassInstance: str = dataclassInstanceIdentifierHardcoded
 
-	sourcePathPackage: PurePosixPath | None = theNumbaFlow.pathPackage
-	sourcePackageIdentifier: ast_Identifier | None = theNumbaFlow.packageIdentifier
+	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 = theNumbaFlow.fileExtension
+	fileExtension: str = packageSettings.fileExtension
 	pathFilenameFoldsTotal: PurePosixPath = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
 
 	# ========================================
 	# Logical identifiers (as opposed to physical identifiers)
-	packageIdentifier: ast_Identifier | None = None
+	packageIdentifier: str | 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
+	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
 
 	# ========================================
@@ -181,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