mapFolding 0.12.3__py3-none-any.whl → 0.13.1__py3-none-any.whl

mapFolding/basecamp.py

@@ -31,11 +31,11 @@ from os import PathLike
 from pathlib import PurePath
 import contextlib
 
-def countFolds(listDimensions: Sequence[int] | None = None  # noqa: C901
+def countFolds(listDimensions: Sequence[int] | None = None  # noqa: C901, PLR0912, PLR0915
 				, pathLikeWriteFoldsTotal: PathLike[str] | PurePath | None = None
 				, computationDivisions: int | str | None = None
-				, CPUlimit: int | float | bool | None = None
-				# , * I need to improve `standardizedEqualToCallableReturn` so it will work with keyword arguments
+				# , * # TODO improve `standardizedEqualToCallableReturn` so it will work with keyword arguments
+				, CPUlimit: int | float | bool | None = None  # noqa: FBT001
 				, mapShape: tuple[int, ...] | None = None
 				, oeisID: str | None = None
 				, oeis_n: int | None = None
@@ -142,7 +142,7 @@ def countFolds(listDimensions: Sequence[int] | None = None  # noqa: C901
 		mapFoldingState = doTheNeedful(mapFoldingState)
 		foldsTotal = mapFoldingState.foldsTotal
 
-	elif flow == 'theorem2' and any(dimension > 2 for dimension in mapShape):  # noqa: PLR2004
+	elif flow == 'theorem2' and any(dimension > 2 for dimension in mapShape):
 		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
@@ -154,7 +154,7 @@ def countFolds(listDimensions: Sequence[int] | None = None  # noqa: C901
 
 		foldsTotal = mapFoldingState.foldsTotal
 
-	elif flow == 'theorem2Trimmed' and any(dimension > 2 for dimension in mapShape):  # noqa: PLR2004
+	elif flow == 'theorem2Trimmed' and any(dimension > 2 for dimension in mapShape):
 		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 
@@ -166,7 +166,7 @@ def countFolds(listDimensions: Sequence[int] | None = None  # noqa: C901
 
 		foldsTotal = mapFoldingState.foldsTotal
 
-	elif (flow == 'theorem2Numba' or taskDivisions == 0) and any(dimension > 2 for dimension in mapShape):  # noqa: PLR2004
+	elif (flow == 'theorem2Numba' or taskDivisions == 0) and any(dimension > 2 for dimension in mapShape):
 		from mapFolding.dataBaskets import MapFoldingState  # noqa: PLC0415
 		mapFoldingState: MapFoldingState = MapFoldingState(mapShape)
 

mapFolding/dataBaskets.py

@@ -29,122 +29,109 @@ import dataclasses
 class MapFoldingState:
 	"""Core computational state for map folding algorithms.
 
-	(AI generated docstring)
-
-	This class encapsulates all data needed to perform map folding computations,
-	from the basic map dimensions through the complex internal arrays needed
-	for efficient algorithmic processing. It serves as both a data container
-	and a computational interface, providing properties and methods that
-	abstract the underlying complexity.
-
-	The class handles automatic initialization of all computational arrays
-	based on the map dimensions, ensuring consistent sizing and type usage
-	throughout the computation. It also manages the relationship between
-	different data domains (leaves, elephino, folds) defined in the type system.
-
-	Key Design Features include automatic array sizing based on map dimensions,
-	type-safe access to computational data, lazy initialization of expensive arrays,
-	integration with NumPy for performance, and metadata preservation for code generation.
+	This class encapsulates all data needed to perform map folding computations and metadata useful for code transformations.
 
 	Attributes
 	----------
 	mapShape : tuple[DatatypeLeavesTotal, ...]
 		Dimensions of the map being analyzed for folding patterns.
 	groupsOfFolds : DatatypeFoldsTotal = DatatypeFoldsTotal(0)
-		Current count of distinct folding pattern groups discovered.
+		Current count of distinct folding pattern groups: each group has `leavesTotal`-many foldings.
 	gap1ndex : DatatypeElephino = DatatypeElephino(0)
-		Current position in gap enumeration algorithms.
+		The current 1-indexed position of the 'gap' during computation: 1-indexed as opposed to 0-indexed.
 	gap1ndexCeiling : DatatypeElephino = DatatypeElephino(0)
-		Upper bound for gap enumeration operations.
+		The upper bound of `gap1ndex`.
 	indexDimension : DatatypeLeavesTotal = DatatypeLeavesTotal(0)
-		Current dimension being processed in multi-dimensional algorithms.
+		The current 0-indexed position of the dimension during computation.
 	indexLeaf : DatatypeLeavesTotal = DatatypeLeavesTotal(0)
-		Current leaf being processed in sequential algorithms.
+		The current 0-indexed position of a leaf in a loop during computation: not to be confused with `leaf1ndex`.
 	indexMiniGap : DatatypeElephino = DatatypeElephino(0)
-		Current position within a gap subdivision.
+		The current 0-indexed position of a 'gap' in a loop during computation.
 	leaf1ndex : DatatypeLeavesTotal = DatatypeLeavesTotal(1)
-		One-based leaf index for algorithmic compatibility.
+		The current 1-indexed position of the leaf during computation: 1-indexed as opposed to 0-indexed.
 	leafConnectee : DatatypeLeavesTotal = DatatypeLeavesTotal(0)
 		Target leaf for connection operations.
 	dimensionsUnconstrained : DatatypeLeavesTotal = None
 		Count of dimensions not subject to folding constraints.
 	countDimensionsGapped : Array1DLeavesTotal = None
-		Array tracking gap counts across dimensions.
+		Array tracking computed number of dimensions with gaps.
 	gapRangeStart : Array1DElephino = None
-		Array of starting positions for gap ranges.
+		Array tracking computed starting positions of gap ranges.
 	gapsWhere : Array1DLeavesTotal = None
 		Array indicating locations of gaps in the folding pattern.
 	leafAbove : Array1DLeavesTotal = None
-		Array mapping each leaf to the leaf above it in the folding.
+		Array tracking the leaves above to the current leaf, `leaf1ndex`, during computation.
 	leafBelow : Array1DLeavesTotal = None
-		Array mapping each leaf to the leaf below it in the folding.
+		Array tracking the leaves below to the current leaf, `leaf1ndex`, during computation.
 	connectionGraph : Array3D
-		Three-dimensional representation of leaf connectivity.
+		Unchanging array representing connections between all leaves.
 	dimensionsTotal : DatatypeLeavesTotal
-		Total number of dimensions in the map.
+		Unchanging total number of dimensions in the map.
 	leavesTotal : DatatypeLeavesTotal
-		Total number of individual leaves in the map.
+		Unchanging total number of leaves in the map.
 
 	"""
 
 	mapShape: tuple[DatatypeLeavesTotal, ...] = dataclasses.field(init=True, metadata={'elementConstructor': 'DatatypeLeavesTotal'})
+	"""Dimensions of the map being analyzed for folding patterns."""
 
 	groupsOfFolds: DatatypeFoldsTotal = dataclasses.field(default=DatatypeFoldsTotal(0), metadata={'theCountingIdentifier': True})
+	"""Current count of distinct folding pattern groups: each group has `leavesTotal`-many foldings."""
 
 	gap1ndex: DatatypeElephino = DatatypeElephino(0)  # noqa: RUF009
+	"""The current 1-indexed position of the 'gap' during computation: 1-indexed as opposed to 0-indexed."""
 	gap1ndexCeiling: DatatypeElephino = DatatypeElephino(0)  # noqa: RUF009
+	"""The upper bound of `gap1ndex`."""
 	indexDimension: DatatypeLeavesTotal = DatatypeLeavesTotal(0)  # noqa: RUF009
+	"""The current 0-indexed position of the dimension during computation."""
 	indexLeaf: DatatypeLeavesTotal = DatatypeLeavesTotal(0)  # noqa: RUF009
+	"""The current 0-indexed position of a leaf in a loop during computation: not to be confused with `leaf1ndex`."""
 	indexMiniGap: DatatypeElephino = DatatypeElephino(0)  # noqa: RUF009
+	"""The current 0-indexed position of a 'gap' in a loop during computation."""
 	leaf1ndex: DatatypeLeavesTotal = DatatypeLeavesTotal(1)  # noqa: RUF009
+	"""The current 1-indexed position of the leaf during computation: 1-indexed as opposed to 0-indexed."""
 	leafConnectee: DatatypeLeavesTotal = DatatypeLeavesTotal(0)  # noqa: RUF009
+	"""Target leaf for connection operations."""
 
 	dimensionsUnconstrained: DatatypeLeavesTotal = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	"""Count of dimensions not subject to folding constraints."""
 
 	countDimensionsGapped: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	"""Array tracking computed number of dimensions with gaps."""
 	gapRangeStart: Array1DElephino = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DElephino.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	"""Array tracking computed starting positions of gap ranges."""
 	gapsWhere: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	"""Array indicating locations of gaps in the folding pattern."""
 	leafAbove: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	"""Array tracking the leaves above to the current leaf, `leaf1ndex`, during computation."""
 	leafBelow: Array1DLeavesTotal = dataclasses.field(default=None, init=True, metadata={'dtype': Array1DLeavesTotal.__args__[1].__args__[0]}) # pyright: ignore[reportAssignmentType, reportAttributeAccessIssue, reportUnknownMemberType]
+	"""Array tracking the leaves below to the current leaf, `leaf1ndex`, during computation."""
 
 	connectionGraph: Array3D = dataclasses.field(init=False, metadata={'dtype': Array3D.__args__[1].__args__[0]}) # pyright: ignore[reportUnknownMemberType, reportAttributeAccessIssue]
+	"""Unchanging array representing connections between all leaves."""
 	dimensionsTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
+	"""Unchanging total number of dimensions in the map."""
 	leavesTotal: DatatypeLeavesTotal = dataclasses.field(init=False)
+	"""Unchanging total number of leaves in the map."""
 	@property
 	def foldsTotal(self) -> DatatypeFoldsTotal:
-		"""Calculate the total number of possible folding patterns for this map.
-
-		(AI generated docstring)
+		"""The total number of possible folding patterns for this map.
 
 		Returns
 		-------
-		totalFoldingPatterns : DatatypeFoldsTotal
+		totalFoldings : DatatypeFoldsTotal
 			The complete count of distinct folding patterns achievable with the current map configuration.
 
-		Notes
-		-----
-		This represents the fundamental result of map folding analysis - the total
-		number of unique ways a map can be folded given its dimensional constraints.
-
 		"""
 		return DatatypeFoldsTotal(self.leavesTotal) * self.groupsOfFolds
 
 	def __post_init__(self) -> None:
-		"""Initialize all computational arrays and derived values after dataclass construction.
-
-		(AI generated docstring)
-
-		This method performs the expensive operations needed to prepare the state
-		for computation, including array allocation, dimension calculation, and
-		connection graph generation. It runs automatically after the dataclass
-		constructor completes.
+		"""Ensure all fields have a value.
 
 		Notes
 		-----
-		Arrays that are not explicitly provided (None) are automatically
-		allocated with appropriate sizes based on the map dimensions.
-		The connection graph is always regenerated to ensure consistency
-		with the provided map shape.
+		Arrays that are not explicitly provided (None) are automatically allocated with appropriate sizes based on the map
+		dimensions. `dimensionsTotal`, `leavesTotal`, and `connectionGraph` cannot be set: they are calculated.
 
 		"""
 		self.dimensionsTotal = DatatypeLeavesTotal(len(self.mapShape))

mapFolding/oeis.py

@@ -8,7 +8,7 @@ folding ecosystem into the broader mathematical community through comprehensive
 integration with the Online Encyclopedia of Integer Sequences (OEIS). This bridge
 enables validation of computational results against established mathematical
 knowledge while supporting the discovery of new sequence values through the
-sophisticated computational pipeline.
+sophisticated computational assembly line.
 
 The integration provides multiple pathways for mathematical verification: direct
 computation of OEIS sequences using the complete algorithmic implementation,

mapFolding/someAssemblyRequired/RecipeJob.py

@@ -1,31 +1,4 @@
-"""
-Map folding AST transformation system: Configuration management and transformation orchestration.
-
-This module provides the configuration orchestration layer of the map folding AST transformation
-system, implementing comprehensive recipes that coordinate the entire transformation process from
-abstract mathematical algorithms to optimized computational modules. The `RecipeJobTheorem2Numba`
-dataclass serves as the central configuration blueprint that bridges pattern recognition, dataclass
-decomposition, function optimization, and Numba compilation into a unified transformation process.
-
-The recipe system addresses the complexity of managing transformation parameters across multiple
-stages while maintaining consistency between source algorithm metadata and target optimization
-requirements. The orchestration layer coordinates the systematic extraction of mathematical
-functions from source modules, embedding of concrete parameter values, elimination of dead code
-paths, and generation of standalone Python modules optimized for specific map dimensions through
-the complete transformation process.
-
-Configuration management separates source analysis capabilities from target generation parameters,
-enabling systematic exploration of computational spaces through automated generation of optimized
-solvers. Source analysis encompasses parsing and analysis of abstract syntax trees from generic
-algorithm modules, extraction of specific mathematical functions for specialization, and
-identification of dataclass structures for parameter embedding. Target generation coordinates
-creation of standalone Python modules with optimized implementations, integration of Numba
-optimization directives, and preservation of mathematical correctness throughout optimization.
-
-The recipe system enables the broader map folding research framework by providing systematic
-control over the transformation process while ensuring that generated modules achieve maximum
-performance through compile-time specialization and runtime optimization strategies.
-"""
+"""Configuration by dataclass."""
 
 from ast import Module
 from astToolkit import identifierDotAttribute, parseLogicalPath2astModule
@@ -36,24 +9,21 @@ from mapFolding import (
 from mapFolding.someAssemblyRequired import dataclassInstanceIdentifierDEFAULT, ShatteredDataclass
 from mapFolding.someAssemblyRequired.transformationTools import shatter_dataclassesDOTdataclass
 from pathlib import Path, PurePosixPath
-from typing import TypeAlias
 import dataclasses
 
 @dataclasses.dataclass
-class RecipeJobTheorem2Numba:
-	"""Configuration recipe for generating Numba-optimized map folding computation jobs.
+class RecipeJobTheorem2:
+	"""Configuration recipe for generating map folding computation jobs.
 
 	This dataclass serves as the central configuration hub for the code transformation
-	pipeline that converts generic map folding algorithms into highly optimized,
+	assembly line that converts generic map folding algorithms into highly optimized,
 	specialized computation modules. The recipe encapsulates all parameters required
 	for source code analysis, target file generation, datatype mapping, and compilation
 	optimization settings.
 
 	The transformation process operates by extracting functions from source modules,
 	embedding concrete parameter values, eliminating dead code paths, and generating
-	standalone Python modules optimized for specific map dimensions. These generated
-	modules achieve maximum performance through Numba just-in-time compilation and
-	embedded compile-time constants.
+	standalone Python modules optimized for specific map dimensions.
 
 	The recipe maintains both source configuration (where to find the generic algorithm)
 	and target configuration (where to write the optimized module), along with the
@@ -61,84 +31,118 @@ class RecipeJobTheorem2Numba:
 
 	Attributes
 	----------
-	state: The map folding computation state containing dimensions and initial values.
-	foldsTotalEstimated: Estimated total number of folds for progress tracking (0).
-	shatteredDataclass: Deconstructed dataclass metadata for code transformation.
-	source_astModule: Parsed AST of the source module containing the generic algorithm.
-	sourceCountCallable: Name of the counting function to extract ('count').
-	sourceLogicalPathModuleDataclass: Logical path to the dataclass module.
-	sourceDataclassIdentifier: Name of the source dataclass ('MapFoldingState').
-	sourceDataclassInstance: Instance identifier for the dataclass.
-	sourcePathPackage: Path to the source package.
-	sourcePackageIdentifier: Name of the source package.
-	pathPackage: Override path for the target package (None).
-	pathModule: Override path for the target module directory.
-	fileExtension: File extension for generated modules.
-	pathFilenameFoldsTotal: Path for writing fold count results.
-	packageIdentifier: Target package identifier (None).
-	logicalPathRoot: Logical path root corresponding to filesystem directory.
-	moduleIdentifier: Target module identifier.
-	countCallable: Name of the counting function in generated module.
-	dataclassIdentifier: Target dataclass identifier.
-	dataclassInstance: Target dataclass instance identifier.
-	logicalPathModuleDataclass: Logical path to target dataclass module.
-	DatatypeFoldsTotal: Type alias for fold count datatype.
-	DatatypeElephino: Type alias for intermediate computation datatype.
-	DatatypeLeavesTotal: Type alias for leaf count datatype.
+	state : MapFoldingState
+		The map folding computation state containing dimensions and initial values.
+	foldsTotalEstimated : int = 0
+		Estimated total number of folds for progress tracking.
+	shatteredDataclass : ShatteredDataclass = None
+		Deconstructed dataclass metadata for code transformation.
+	source_astModule : Module
+		Parsed AST of the source module containing the generic algorithm.
+	sourceCountCallable : str = 'count'
+		Name of the counting function to extract.
+	sourceLogicalPathModuleDataclass : identifierDotAttribute
+		Logical path to the dataclass module.
+	sourceDataclassIdentifier : str = 'MapFoldingState'
+		Name of the source dataclass.
+	sourceDataclassInstance : str
+		Instance identifier for the dataclass.
+	sourcePathPackage : PurePosixPath | None
+		Path to the source package.
+	sourcePackageIdentifier : str | None
+		Name of the source package.
+	pathPackage : PurePosixPath | None = None
+		Override path for the target package.
+	pathModule : PurePosixPath | None
+		Override path for the target module directory.
+	fileExtension : str
+		File extension for generated modules.
+	pathFilenameFoldsTotal : PurePosixPath = None
+		Path for writing fold count results.
+	packageIdentifier : str | None = None
+		Target package identifier.
+	logicalPathRoot : identifierDotAttribute | None = None
+		Logical path root; probably corresponds to physical filesystem directory.
+	moduleIdentifier : str = None
+		Target module identifier.
+	countCallable : str
+		Name of the counting function in generated module.
+	dataclassIdentifier : str | None
+		Target dataclass identifier.
+	dataclassInstance : str | None
+		Target dataclass instance identifier.
+	logicalPathModuleDataclass : identifierDotAttribute | None
+		Logical path to target dataclass module.
+	DatatypeFoldsTotal : TypeAlias
+		Type alias for fold count datatype.
+	DatatypeElephino : TypeAlias
+		Type alias for intermediate computation datatype.
+	DatatypeLeavesTotal : TypeAlias
+		Type alias for leaf count datatype.
 	"""
 
 	state: MapFoldingState
-	# TODO create function to calculate `foldsTotalEstimated`
+	"""The map folding computation state containing dimensions and initial values."""
 	foldsTotalEstimated: int = 0
+	"""Estimated total number of folds for progress tracking."""
 	shatteredDataclass: ShatteredDataclass = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
+	"""Deconstructed dataclass metadata for code transformation."""
 
 	# Source -----------------------------------------
 	source_astModule: Module = parseLogicalPath2astModule('mapFolding.syntheticModules.theorem2Numba')  # noqa: RUF009
+	"""Parsed AST of the source module containing the generic algorithm."""
 	sourceCountCallable: str = 'count'
+	"""Name of the counting function to extract."""
 
 	sourceLogicalPathModuleDataclass: identifierDotAttribute = 'mapFolding.dataBaskets'
+	"""Logical path to the dataclass module."""
 	sourceDataclassIdentifier: str = 'MapFoldingState'
+	"""Name of the source dataclass."""
 	sourceDataclassInstance: str = dataclassInstanceIdentifierDEFAULT
+	"""Instance identifier for the dataclass."""
 
 	sourcePathPackage: PurePosixPath | None = PurePosixPath(packageSettings.pathPackage)  # noqa: RUF009
+	"""Path to the source package."""
 	sourcePackageIdentifier: str | None = packageSettings.identifierPackage
+	"""Name of the source package."""
 
 	# Filesystem, names of physical objects ------------------------------------------
 	pathPackage: PurePosixPath | None = None
+	"""Override path for the target package."""
 	pathModule: PurePosixPath | None = PurePosixPath(getPathRootJobDEFAULT())  # noqa: RUF009
-	""" `pathModule` will override `pathPackage` and `logicalPathRoot`."""
+	"""Override path for the target module directory."""
 	fileExtension: str = packageSettings.fileExtension
+	"""File extension for generated modules."""
 	pathFilenameFoldsTotal: PurePosixPath = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
+	"""Path for writing fold count results."""
 
 	# Logical identifiers, as opposed to physical identifiers ------------------------
 	packageIdentifier: str | None = None
+	"""Target package identifier."""
 	logicalPathRoot: identifierDotAttribute | None = None
-	""" `logicalPathRoot` likely corresponds to a physical filesystem directory."""
+	"""Logical path root; probably corresponds to physical filesystem directory."""
 	moduleIdentifier: str = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
+	"""Target module identifier."""
 	countCallable: str = sourceCountCallable
+	"""Name of the counting function in generated module."""
 	dataclassIdentifier: str | None = sourceDataclassIdentifier
+	"""Target dataclass identifier."""
 	dataclassInstance: str | None = sourceDataclassInstance
+	"""Target dataclass instance identifier."""
 	logicalPathModuleDataclass: identifierDotAttribute | None = sourceLogicalPathModuleDataclass
+	"""Logical path to target dataclass module."""
 
 	# Datatypes ------------------------------------------
-	DatatypeFoldsTotal: TypeAlias = TheDatatypeFoldsTotal
-	DatatypeElephino: TypeAlias = TheDatatypeElephino
-	DatatypeLeavesTotal: TypeAlias = TheDatatypeLeavesTotal
-
-	def _makePathFilename(self,
-			pathRoot: PurePosixPath | None = None,
-			logicalPathINFIX: identifierDotAttribute | None = None,
-			filenameStem: str | None = None,
-			fileExtension: str | None = None,
-			) -> PurePosixPath:
+	type DatatypeFoldsTotal = TheDatatypeFoldsTotal
+	"""Type alias for datatype linked to the magnitude of `foldsTotal`."""
+	type DatatypeElephino = TheDatatypeElephino
+	"""Type alias for intermediate computation datatype."""
+	type DatatypeLeavesTotal = TheDatatypeLeavesTotal
+	"""Type alias for datatype linked to the magnitude of `leavesTotal`."""
+
+	def _makePathFilename(self, pathRoot: PurePosixPath | None = None, logicalPathINFIX: identifierDotAttribute | None = None, filenameStem: str | None = None, fileExtension: str | None = None) -> PurePosixPath:
 		"""Construct a complete file path from component parts.
 
-		(AI generated docstring)
-
-		This helper method builds filesystem paths by combining a root directory,
-		optional subdirectory structure, filename stem, and file extension. It provides
-		sensible defaults for missing components based on the recipe configuration.
-
 		Parameters
 		----------
 		pathRoot : PurePosixPath | None = None
@@ -172,8 +176,6 @@ class RecipeJobTheorem2Numba:
 	def pathFilenameModule(self) -> PurePosixPath:
 		"""Generate the complete path and filename for the output module.
 
-		(AI generated docstring)
-
 		This property computes the target location where the generated computation
 		module will be written. It respects the `pathModule` override if specified,
 		otherwise constructs the path using the default package structure.
@@ -192,8 +194,6 @@ class RecipeJobTheorem2Numba:
 	def __post_init__(self) -> None:
 		"""Initialize computed fields and validate configuration after dataclass creation.
 
-		(AI generated docstring)
-
 		This method performs post-initialization setup including deriving module
 		identifier from map shape if not explicitly provided, setting default paths
 		for fold total output files, and creating shattered dataclass metadata for

mapFolding/someAssemblyRequired/_toolkitContainers.py

@@ -217,10 +217,10 @@ class DeReConstructField2ast:
 		self.ast_keyword_field__field = Make.keyword(self.name, self.astName)
 		self.ast_nameDOTname = Make.Attribute(Make.Name(dataclassesDOTdataclassInstanceIdentifier), self.name)
 
-		self.astAnnotation = raiseIfNone(NodeTourist[ast.AnnAssign, ast.Name | None](
+		self.astAnnotation = cast('ast.Name', raiseIfNone(NodeTourist(
 			findThis = Be.AnnAssign.targetIs(IfThis.isNameIdentifier(self.name))
-			, doThat = Then.extractIt(cast("Callable[[ast.AnnAssign], ast.Name | None]", DOT.annotation))
-			).captureLastMatch(dataclassClassDef))
+			, doThat = Then.extractIt(DOT.annotation)
+			).captureLastMatch(dataclassClassDef)))
 
 		self.ast_argAnnotated = Make.arg(self.name, self.astAnnotation)
 

mapFolding/someAssemblyRequired/makeAllModules.py

@@ -299,7 +299,7 @@ def makeDaoOfMapFolding(astModule: ast.Module, moduleIdentifier: str, callableId
 		ingredientsFunctionDispatcher.imports.update(shatteredDataclass.imports)
 		targetCallableIdentifier = ingredientsFunction.astFunctionDef.name
 		ingredientsFunctionDispatcher = unpackDataclassCallFunctionRepackDataclass(ingredientsFunctionDispatcher, targetCallableIdentifier, shatteredDataclass)
-		astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist[ast.Return, ast.expr | None](Be.Return.valueIs(Be.Tuple)
+		astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist(Be.Return.valueIs(Be.Tuple)
 				, doThat=Then.extractIt(DOT.value)).captureLastMatch(ingredientsFunction.astFunctionDef)))
 		astTuple.ctx = ast.Store()
 
@@ -329,7 +329,7 @@ def makeDaoOfMapFoldingParallel(astModule: ast.Module, moduleIdentifier: str, ca
 
 	The generated module contains multiple functions including core counting function with parallel-aware task filtering,
 	dataclass unpacking/repacking function for process communication, and main dispatcher function that manages the parallel
-	execution pipeline.
+	execution assembly line.
 
 	Parameters
 	----------
@@ -591,15 +591,12 @@ def trimTheorem2(astModule: ast.Module, moduleIdentifier: str, callableIdentifie
 
 	(AI generated docstring)
 
-	Creates a trimmed version of the Theorem 2 implementation by eliminating
-	conditional logic that is not needed under specific constraint assumptions.
-	This transformation removes checks for unconstrained dimensions, simplifying
-	the algorithm for cases where dimensional constraints are guaranteed to be
-	satisfied by external conditions.
+	Creates a trimmed version of the Theorem 2 implementation by eliminating conditional logic that is not needed under specific
+	constraint assumptions. This transformation removes checks for unconstrained dimensions, simplifying the algorithm for cases
+	where dimensional constraints are guaranteed to be satisfied by external conditions.
 
-	The trimming operation is particularly valuable for generating lean implementations
-	where the calling context ensures that certain conditions will always be met,
-	allowing the removal of defensive programming constructs that add computational
+	The trimming operation is particularly valuable for generating lean implementations where the calling context ensures that
+	certain conditions will always be met, allowing the removal of defensive programming constructs that add computational
 	overhead without providing benefits in the constrained environment.
 
 	Parameters
@@ -746,7 +743,7 @@ def makeUnRePackDataclass(astImportFrom: ast.ImportFrom) -> None:
 	targetCallableIdentifier = astImportFrom.names[0].name
 	ingredientsFunction = raiseIfNone(unpackDataclassCallFunctionRepackDataclass(ingredientsFunction, targetCallableIdentifier, shatteredDataclass))
 	targetFunctionDef: ast.FunctionDef = raiseIfNone(extractFunctionDef(parseLogicalPath2astModule(raiseIfNone(astImportFrom.module)), targetCallableIdentifier))
-	astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist[ast.Return, ast.expr | None](Be.Return.valueIs(Be.Tuple)
+	astTuple: ast.Tuple = cast('ast.Tuple', raiseIfNone(NodeTourist(Be.Return.valueIs(Be.Tuple)
 			, doThat=Then.extractIt(DOT.value)).captureLastMatch(targetFunctionDef)))
 	astTuple.ctx = ast.Store()
 

mapFolding/someAssemblyRequired/makeJobTheorem2Numba.py

@@ -35,7 +35,7 @@ from astToolkit.transformationTools import write_astModule
 from hunterMakesPy import autoDecodingRLE, raiseIfNone
 from mapFolding import getPathFilenameFoldsTotal, MapFoldingState, packageSettings
 from mapFolding.someAssemblyRequired import IfThis
-from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2Numba
+from mapFolding.someAssemblyRequired.RecipeJob import RecipeJobTheorem2
 from mapFolding.someAssemblyRequired.toolkitNumba import decorateCallableWithNumba, parametersNumbaLight, SpicesJobNumba
 from mapFolding.syntheticModules.initializeCount import initializeGroupsOfFolds
 from pathlib import PurePosixPath
@@ -46,26 +46,9 @@ import ast
 if TYPE_CHECKING:
 	from collections.abc import Callable
 
-# Configuration lists for code optimization and dead code elimination
-listIdentifiersNotUsedAllHARDCODED: list[str] = ['concurrencyLimit', 'foldsTotal', 'mapShape']
-"""Identifiers that are universally unused across all optimization contexts."""
-
-listIdentifiersNotUsedParallelSequentialHARDCODED: list[str] = ['indexLeaf']
-"""Identifiers unused in both parallel and sequential execution modes."""
-
-listIdentifiersNotUsedSequentialHARDCODED: list[str] = ['foldGroups', 'taskDivisions', 'taskIndex']
-"""Identifiers unused specifically in sequential execution mode."""
-
-listIdentifiersReplacedHARDCODED: list[str] = ['groupsOfFolds']
-"""Identifiers that get replaced with optimized equivalents during transformation."""
-
 listIdentifiersStaticValuesHARDCODED: list[str] = ['dimensionsTotal', 'leavesTotal']
-"""Identifiers with compile-time constant values that can be embedded directly."""
 
-listIdentifiersNotUsedHARDCODED: list[str] = listIdentifiersStaticValuesHARDCODED + listIdentifiersReplacedHARDCODED + listIdentifiersNotUsedAllHARDCODED + listIdentifiersNotUsedParallelSequentialHARDCODED + listIdentifiersNotUsedSequentialHARDCODED
-"""Complete list of all identifiers that can be eliminated during optimization."""
-
-def addLauncherNumbaProgress(ingredientsModule: IngredientsModule, ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2Numba, spices: SpicesJobNumba) -> tuple[IngredientsModule, IngredientsFunction]:
+def addLauncherNumbaProgress(ingredientsModule: IngredientsModule, ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2, spices: SpicesJobNumba) -> tuple[IngredientsModule, IngredientsFunction]:
 	"""Add progress tracking capabilities to a Numba-optimized function.
 
 	(AI generated docstring)
@@ -130,7 +113,7 @@ if __name__ == '__main__':
 
 	return ingredientsModule, ingredientsFunction
 
-def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2Numba) -> IngredientsFunction:
+def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: IngredientsFunction, job: RecipeJobTheorem2) -> IngredientsFunction:
 	"""Convert function parameters into initialized variables with concrete values.
 
 	(AI generated docstring)
@@ -201,12 +184,12 @@ def move_arg2FunctionDefDOTbodyAndAssignInitialValues(ingredientsFunction: Ingre
 	ast.fix_missing_locations(ingredientsFunction.astFunctionDef)
 	return ingredientsFunction
 
-def makeJobNumba(job: RecipeJobTheorem2Numba, spices: SpicesJobNumba) -> None:
+def makeJobNumba(job: RecipeJobTheorem2, spices: SpicesJobNumba) -> None:
 	"""Generate an optimized Numba-compiled computation module for map folding calculations.
 
 	(AI generated docstring)
 
-	This function orchestrates the complete code transformation pipeline to convert
+	This function orchestrates the complete code transformation assembly line to convert
 	a generic map folding algorithm into a highly optimized, specialized computation
 	module. The transformation process includes:
 
@@ -234,10 +217,6 @@ def makeJobNumba(job: RecipeJobTheorem2Numba, spices: SpicesJobNumba) -> None:
 	astFunctionDef: ast.FunctionDef = raiseIfNone(extractFunctionDef(job.source_astModule, job.countCallable))
 	ingredientsCount: IngredientsFunction = IngredientsFunction(astFunctionDef, LedgerOfImports())
 
-	# Remove `foldGroups` and any other unused statements, so you can dynamically determine which variables are not used
-	# NodeChanger[ast.Name, None](Be.Assign.targetsIs(lambda list_expr: any(IfThis.isSubscriptIdentifier('foldGroups')(node) for node in list_expr)) , Then.removeIt).visit(ingredientsCount.astFunctionDef)  # noqa: ERA001
-
-	# replace identifiers with static values with their values, so you can dynamically determine which variables are not used
 	listIdentifiersStaticValues: list[str] = listIdentifiersStaticValuesHARDCODED
 	for identifier in listIdentifiersStaticValues:
 		findThis: Callable[[ast.AST], TypeIs[ast.Name] | bool] = IfThis.isNameIdentifier(identifier)
@@ -308,7 +287,7 @@ if __name__ == '__main__':
 		)
 		ingredientsModule.appendPrologue(statement=statement)
 
-	ingredientsCount.imports.removeImportFromModule('mapFolding.theSSOT')
+	ingredientsCount.imports.removeImportFromModule('mapFolding.dataBaskets')
 
 	listNumPyTypeConfigs = [
 		DatatypeConfig(fml='Array1DLeavesTotal', Z0Z_module='numpy', Z0Z_type_name='uint8', Z0Z_asname='Array1DLeavesTotal'),
@@ -347,15 +326,11 @@ if __name__ == '__main__':
 	"""
 
 if __name__ == '__main__':
-	mapShape = (2,4)
-	state = MapFoldingState(mapShape)
-	state = initializeGroupsOfFolds(state)
-	# foldsTotalEstimated = getFoldsTotalKnown(state.mapShape) // state.leavesTotal  # noqa: ERA001
-	# foldsTotalEstimated = dictionaryEstimates[state.mapShape] // state.leavesTotal  # noqa: ERA001
-	foldsTotalEstimated = 0
+	state = initializeGroupsOfFolds(MapFoldingState((2,4)))
 	pathModule = PurePosixPath(packageSettings.pathPackage, 'jobs')
 	pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(state.mapShape, pathModule))
-	aJob = RecipeJobTheorem2Numba(state, foldsTotalEstimated, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
+	aJob = RecipeJobTheorem2(state, pathModule=pathModule, pathFilenameFoldsTotal=pathFilenameFoldsTotal)
 	spices = SpicesJobNumba(useNumbaProgressBar=False, parametersNumba=parametersNumbaLight)
-	# spices = SpicesJobNumba()  # noqa: ERA001
 	makeJobNumba(aJob, spices)
+
+# TODO Improve this module with lessons learned in `makeJobTheorem2codon`.