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

mapFolding/reference/flattened.py

@@ -380,7 +380,7 @@ def parseDimensions(dimensions: Sequence[int], parameterName: str = 'unnamed par
 def setCPUlimit(CPUlimit: bool | float | int | None) -> int:
 	# if not (CPUlimit is None or isinstance(CPUlimit, (bool, int, float))):
 	#	 CPUlimit = oopsieKwargsie(CPUlimit)
-	# concurrencyLimit = defineConcurrencyLimit(CPUlimit)
+	# concurrencyLimit = defineConcurrencyLimit(limit=CPUlimit)
 	# numba.set_num_threads(concurrencyLimit)
 	concurrencyLimitHARDCODED = 1
 	concurrencyLimit = concurrencyLimitHARDCODED

mapFolding/someAssemblyRequired/RecipeJob.py

@@ -31,9 +31,8 @@ from ast import Module
 from astToolkit import identifierDotAttribute, parseLogicalPath2astModule
 from mapFolding import (
 	DatatypeElephino as TheDatatypeElephino, DatatypeFoldsTotal as TheDatatypeFoldsTotal,
-	DatatypeLeavesTotal as TheDatatypeLeavesTotal, getPathFilenameFoldsTotal, getPathRootJobDEFAULT,
-	MapFoldingState, packageSettings,
-)
+	DatatypeLeavesTotal as TheDatatypeLeavesTotal, getPathFilenameFoldsTotal, getPathRootJobDEFAULT, MapFoldingState,
+	packageSettings)
 from mapFolding.someAssemblyRequired import dataclassInstanceIdentifierDEFAULT, ShatteredDataclass
 from mapFolding.someAssemblyRequired.transformationTools import shatter_dataclassesDOTdataclass
 from pathlib import Path, PurePosixPath
@@ -60,59 +59,58 @@ class RecipeJobTheorem2Numba:
 	and target configuration (where to write the optimized module), along with the
 	computational state that provides concrete values for the transformation process.
 
-	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.
+	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
 	# TODO create function to calculate `foldsTotalEstimated`
 	foldsTotalEstimated: int = 0
 	shatteredDataclass: ShatteredDataclass = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
 
-	# ========================================
-	# Source
-	source_astModule: Module = parseLogicalPath2astModule('mapFolding.syntheticModules.theorem2Numba')
+	# Source -----------------------------------------
+	source_astModule: Module = parseLogicalPath2astModule('mapFolding.syntheticModules.theorem2Numba')  # noqa: RUF009
 	sourceCountCallable: str = 'count'
 
 	sourceLogicalPathModuleDataclass: identifierDotAttribute = 'mapFolding.dataBaskets'
 	sourceDataclassIdentifier: str = 'MapFoldingState'
 	sourceDataclassInstance: str = dataclassInstanceIdentifierDEFAULT
 
-	sourcePathPackage: PurePosixPath | None = PurePosixPath(packageSettings.pathPackage)
-	sourcePackageIdentifier: str | None = packageSettings.packageName
+	sourcePathPackage: PurePosixPath | None = PurePosixPath(packageSettings.pathPackage)  # noqa: RUF009
+	sourcePackageIdentifier: str | None = packageSettings.identifierPackage
 
-	# ========================================
-	# Filesystem (names of physical objects)
+	# Filesystem, names of physical objects ------------------------------------------
 	pathPackage: PurePosixPath | None = None
-	pathModule: PurePosixPath | None = PurePosixPath(getPathRootJobDEFAULT())
+	pathModule: PurePosixPath | None = PurePosixPath(getPathRootJobDEFAULT())  # noqa: RUF009
 	""" `pathModule` will override `pathPackage` and `logicalPathRoot`."""
 	fileExtension: str = packageSettings.fileExtension
 	pathFilenameFoldsTotal: PurePosixPath = dataclasses.field(default=None, init=True) # pyright: ignore[reportAssignmentType]
 
-	# ========================================
-	# Logical identifiers (as opposed to physical identifiers)
+	# Logical identifiers, as opposed to physical identifiers ------------------------
 	packageIdentifier: str | None = None
 	logicalPathRoot: identifierDotAttribute | None = None
 	""" `logicalPathRoot` likely corresponds to a physical filesystem directory."""
@@ -122,8 +120,7 @@ class RecipeJobTheorem2Numba:
 	dataclassInstance: str | None = sourceDataclassInstance
 	logicalPathModuleDataclass: identifierDotAttribute | None = sourceLogicalPathModuleDataclass
 
-	# ========================================
-	# Datatypes
+	# Datatypes ------------------------------------------
 	DatatypeFoldsTotal: TypeAlias = TheDatatypeFoldsTotal
 	DatatypeElephino: TypeAlias = TheDatatypeElephino
 	DatatypeLeavesTotal: TypeAlias = TheDatatypeLeavesTotal
@@ -136,18 +133,28 @@ class RecipeJobTheorem2Numba:
 			) -> 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: Base directory path. Defaults to package path or current directory.
-			logicalPathINFIX: Dot-separated path segments to insert between root and filename.
-			filenameStem: Base filename without extension. Defaults to module identifier.
-			fileExtension: File extension including dot. Defaults to configured extension.
+		Parameters
+		----------
+		pathRoot : PurePosixPath | None = None
+			Base directory path. Defaults to package path or current directory.
+		logicalPathINFIX : identifierDotAttribute | None = None
+			Dot-separated path segments to insert between root and filename.
+		filenameStem : str | None = None
+			Base filename without extension. Defaults to module identifier.
+		fileExtension : str | None = None
+			File extension including dot. Defaults to configured extension.
+
+		Returns
+		-------
+		pathFilename : PurePosixPath
+			Complete file path as a `PurePosixPath` object.
 
-		Returns:
-			Complete file path as a PurePosixPath object.
 		"""
 		if pathRoot is None:
 			pathRoot = self.pathPackage or PurePosixPath(Path.cwd())
@@ -165,12 +172,17 @@ 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,
+		module will be written. It respects the `pathModule` override if specified,
 		otherwise constructs the path using the default package structure.
 
-		Returns:
+		Returns
+		-------
+		pathFilename : PurePosixPath
 			Complete path to the target module file.
+
 		"""
 		if self.pathModule is None:
 			return self._makePathFilename()
@@ -180,13 +192,16 @@ class RecipeJobTheorem2Numba:
 	def __post_init__(self) -> None:
 		"""Initialize computed fields and validate configuration after dataclass creation.
 
-		This method performs post-initialization setup including:
-		1. Deriving module identifier from map shape if not explicitly provided
-		2. Setting default paths for fold total output files
-		3. Creating shattered dataclass metadata for code transformations
+		(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
+		code transformations.
 
 		The initialization ensures all computed fields are properly set based on
 		the provided configuration and sensible defaults.
+
 		"""
 		pathFilenameFoldsTotal = PurePosixPath(getPathFilenameFoldsTotal(self.state.mapShape))
 

mapFolding/someAssemblyRequired/__init__.py

@@ -1,26 +1,40 @@
 """
 Map folding AST transformation system: Comprehensive framework for converting dataclass-based algorithms to optimized implementations.
 
-This subpackage implements a sophisticated Abstract Syntax Tree (AST) transformation system specifically designed to convert high-level dataclass-based map folding algorithms into highly optimized, Numba-compatible implementations. The transformation system addresses a fundamental challenge in high-performance scientific computing: bridging the gap between maintainable, object-oriented algorithm implementations and the performance requirements of computationally intensive mathematical research.
+This subpackage implements a sophisticated Abstract Syntax Tree (AST) transformation system specifically designed to convert
+high-level dataclass-based map folding algorithms into highly optimized, Numba-compatible implementations. The transformation
+system addresses a fundamental challenge in high-performance scientific computing: bridging the gap between maintainable,
+object-oriented algorithm implementations and the performance requirements of computationally intensive mathematical research.
 
-The map folding problem domain involves complex combinatorial calculations that can require hours or days to complete for specific dimensional configurations. While dataclass-based implementations provide clean, maintainable interfaces for managing complex mathematical state, these objects cannot be directly processed by Numba's just-in-time compiler, which excels at optimizing operations on primitive values and tuples. This subpackage resolves this architectural tension through systematic AST manipulation that preserves algorithmic correctness while enabling dramatic performance improvements.
+The map folding problem domain involves complex combinatorial calculations that can require hours or days to complete for specific
+dimensional configurations. While dataclass-based implementations provide clean, maintainable interfaces for managing complex
+mathematical state, these objects cannot be directly processed by Numba's just-in-time compiler, which excels at optimizing
+operations on primitive values and tuples. This subpackage resolves this architectural tension through systematic AST manipulation
+that preserves algorithmic correctness while enabling dramatic performance improvements.
 
 ## System Architecture
 
-The transformation system operates through a carefully orchestrated sequence of specialized modules, each contributing essential capabilities to the complete transformation process:
+The transformation system operates through a carefully orchestrated sequence of specialized modules, each contributing essential
+capabilities to the complete transformation process:
 
 ### Foundation Layer: Pattern Recognition and Structural Analysis
-- `_toolIfThis`: Extended predicate functions for identifying specific code patterns in AST nodes, particularly conditional expressions and control flow structures essential to map folding computations
-- `_toolkitContainers`: Dataclass decomposition containers that extract individual fields, type annotations, and reconstruction logic from dataclass definitions into manipulatable AST components
+- `_toolIfThis`: Extended predicate functions for identifying specific code patterns in AST nodes, particularly conditional
+	expressions and control flow structures essential to map folding computations
+- `_toolkitContainers`: Dataclass decomposition containers that extract individual fields, type annotations, and reconstruction
+	logic from dataclass definitions into manipulatable AST components
 
 ### Operational Core: Transformation Implementation
-- `transformationTools`: Core functions executing dataclass decomposition, function signature transformation, and calling convention adaptation that convert dataclass-accepting functions into primitive-parameter equivalents
-- `toolkitNumba`: Numba integration tools providing just-in-time compilation optimization with configurable performance parameters and strategic compiler directive application
+- `transformationTools`: Core functions executing dataclass decomposition, function signature transformation, and calling
+	convention adaptation that convert dataclass-accepting functions into primitive-parameter equivalents
+- `toolkitNumba`: Numba integration tools providing just-in-time compilation optimization with configurable performance parameters
+	and strategic compiler directive application
 
 ### Configuration and Orchestration
 - `infoBooth`: Configuration constants, computational complexity estimates, and default identifiers for systematic module generation and optimization decision-making
-- `RecipeJob`: Configuration management dataclasses that coordinate transformation parameters across multiple stages while maintaining consistency between source algorithms and target optimizations
-- `makeAllModules`: Comprehensive transformation orchestration tools that execute complete transformation processes for diverse computational strategies and performance characteristics
+- `RecipeJob`: Configuration management dataclasses that coordinate transformation parameters across multiple stages while
+	maintaining consistency between source algorithms and target optimizations
+- `makeAllModules`: Comprehensive transformation orchestration tools that execute complete transformation processes for diverse
+	computational strategies and performance characteristics
 - `makeJobTheorem2Numba`: Specialized job generation implementing the complete transformation sequence to produce standalone, highly optimized computation modules
 
 ### Utility Extensions
@@ -30,21 +44,32 @@ The transformation system operates through a carefully orchestrated sequence of
 
 The complete transformation follows a systematic three-stage pattern:
 
-1. **Analysis and Decomposition**: Pattern recognition identifies dataclass structures and dependencies, followed by decomposition into constituent AST components including field definitions, type annotations, and initialization patterns.
+1. **Analysis and Decomposition**: Pattern recognition identifies dataclass structures and dependencies, followed by decomposition
+	into constituent AST components including field definitions, type annotations, and initialization patterns.
 
-2. **Function Optimization**: Core transformations convert functions accepting dataclass parameters into functions accepting individual primitive parameters, with systematic updates to signatures, return types, and calling conventions.
+2. **Function Optimization**: Core transformations convert functions accepting dataclass parameters into functions accepting
+	individual primitive parameters, with systematic updates to signatures, return types, and calling conventions.
 
-3. **Compilation Integration**: Numba decorators with carefully configured optimization parameters are applied to transformed functions, enabling aggressive just-in-time compilation with performance characteristics suitable for large-scale computational research.
+3. **Compilation Integration**: Numba decorators with carefully configured optimization parameters are applied to transformed
+	functions, enabling aggressive just-in-time compilation with performance characteristics suitable for large-scale computational
+	research.
 
 ## Generated Module Characteristics
 
-The transformation system produces standalone Python modules with embedded constants replacing parameterized values, eliminated dead code paths, optimized data structures, Numba compilation directives, progress feedback for long-running calculations, and consistent naming conventions with systematic filesystem organization. These modules maintain mathematical correctness while providing significant performance improvements essential to map folding research computational demands.
+The transformation system produces standalone Python modules with embedded constants replacing parameterized values, eliminated
+dead code paths, optimized data structures, Numba compilation directives, progress feedback for long-running calculations, and
+consistent naming conventions with systematic filesystem organization. These modules maintain mathematical correctness while
+providing significant performance improvements essential to map folding research computational demands.
 
 ## Usage Guidance
 
-Begin exploration with `infoBooth` for understanding configuration options and complexity estimates. Proceed to `transformationTools` for core transformation capabilities, then examine `RecipeJob` for orchestration patterns. Advanced users developing custom transformations should study `_toolIfThis` and `_toolkitContainers` for foundational pattern recognition and structural manipulation capabilities.
+Begin exploration with `infoBooth` for understanding configuration options and complexity estimates. Proceed to
+`transformationTools` for core transformation capabilities, then examine `RecipeJob` for orchestration patterns. Advanced users
+developing custom transformations should study `_toolIfThis` and `_toolkitContainers` for foundational pattern recognition and
+structural manipulation capabilities.
 
-The transformation system represents the culmination of systematic AST manipulation research, enabling previously intractable calculations through the strategic application of compiler optimization techniques to abstract mathematical algorithms.
+The transformation system represents the culmination of systematic AST manipulation research, enabling previously intractable
+calculations through the strategic application of compiler optimization techniques to abstract mathematical algorithms.
 """
 
 from mapFolding.someAssemblyRequired.infoBooth import (

mapFolding/someAssemblyRequired/_toolIfThis.py

@@ -24,97 +24,125 @@ Classes:
             algorithm transformations.
 """
 
-from astToolkit import Be, DOT, IfThis as astToolkit_IfThis
+from astToolkit import Be, IfThis as astToolkit_IfThis
 from collections.abc import Callable
-from typing import TypeGuard
+from typing_extensions import TypeIs
 import ast
 
 class IfThis(astToolkit_IfThis):
-	"""
-	Provide predicate functions for matching and filtering AST nodes based on various criteria.
+	"""Provide predicate functions for matching and filtering AST nodes based on various criteria.
+
+	(AI generated docstring)
 
-	The IfThis class contains static methods that generate predicate functions used to test whether AST nodes match
-	specific criteria. These predicates can be used with NodeChanger and NodeTourist to identify and process specific
+	The `IfThis` `class` contains static methods that generate predicate functions used to test whether AST nodes match
+	specific criteria. These predicates can be used with `NodeChanger` and `NodeTourist` to identify and process specific
 	patterns in the AST.
 
-	The class provides predicates for matching various node types, attributes, identifiers, and structural patterns,
+	The `class` provides predicates for matching various node types, attributes, identifiers, and structural patterns,
 	enabling precise targeting of AST elements for analysis or transformation.
+
 	"""
 
 	@staticmethod
-	def isAttributeNamespaceIdentifierGreaterThan0(namespace: str, identifier: str) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
+	def isAttributeNamespaceIdentifierLessThanOrEqual0(namespace: str, identifier: str) -> Callable[[ast.AST], TypeIs[ast.Compare]]:
+		"""Generate a predicate that matches comparison expressions testing if a namespaced attribute is less than or equal to 0.
+
+		(AI generated docstring)
+
+		This function creates a predicate that identifies AST nodes representing comparisons
+		of the form `namespace.identifier <= 0`. It's used to identify conditional
+		expressions that test non-positive values of counting variables or similar constructs.
+
+		Parameters
+		----------
+		namespace : str
+			The namespace or object name containing the attribute.
+		identifier : str
+			The attribute name to test.
+
+		Returns
+		-------
+		predicate : Callable[[ast.AST], TypeIs[ast.Compare]]
+			A predicate function that returns `True` for `Compare` nodes matching the pattern.
+
 		"""
-		Generate a predicate that matches comparison expressions testing if a namespaced attribute is greater than 0.
+		return lambda node: (Be.Compare.leftIs(IfThis.isAttributeNamespaceIdentifier(namespace, identifier))(node)
+					and Be.Compare.opsIs(lambda at: Be.LtE(at[0]))(node)
+				)
+
+	@staticmethod
+	def isAttributeNamespaceIdentifierGreaterThan0(namespace: str, identifier: str) -> Callable[[ast.AST], TypeIs[ast.Compare] | bool]:
+		"""Generate a predicate that matches comparison expressions testing if a namespaced attribute is greater than 0.
+
+		(AI generated docstring)
 
 		This function creates a predicate that identifies AST nodes representing comparisons
 		of the form `namespace.identifier > 0`. It's commonly used to identify conditional
 		expressions that test positive values of counting variables or similar constructs.
 
-		Parameters:
-			namespace: The namespace or object name containing the attribute
-			identifier: The attribute name to test
+		Parameters
+		----------
+		namespace : str
+			The namespace or object name containing the attribute.
+		identifier : str
+			The attribute name to test.
+
+		Returns
+		-------
+		predicate : Callable[[ast.AST], TypeIs[ast.Compare]]
+			A predicate function that returns `True` for `Compare` nodes matching the pattern.
 
-		Returns:
-			A predicate function that returns True for Compare nodes matching the pattern
 		"""
-		return lambda node: (Be.Compare(node)
-					and IfThis.isAttributeNamespaceIdentifier(namespace, identifier)(DOT.left(node))
+		return lambda node: (Be.Compare.leftIs(IfThis.isAttributeNamespaceIdentifier(namespace, identifier))(node)
 					and Be.Gt(node.ops[0])
 					and IfThis.isConstant_value(0)(node.comparators[0]))
 
 	@staticmethod
-	def isIfAttributeNamespaceIdentifierGreaterThan0(namespace: str, identifier: str) -> Callable[[ast.AST], TypeGuard[ast.If] | bool]:
-		"""
-		Generate a predicate that matches If statements testing if a namespaced attribute is greater than 0.
+	def isIfAttributeNamespaceIdentifierGreaterThan0(namespace: str, identifier: str) -> Callable[[ast.AST], TypeIs[ast.If]]:
+		"""Generate a predicate that matches If statements testing if a namespaced attribute is greater than 0.
+
+		(AI generated docstring)
 
 		This function creates a predicate that identifies AST nodes representing conditional
 		statements of the form `if namespace.identifier > 0:`. It's used to find control
 		flow structures that depend on positive values of specific attributes.
 
-		Parameters:
-			namespace: The namespace or object name containing the attribute
-			identifier: The attribute name to test
+		Parameters
+		----------
+		namespace : str
+			The namespace or object name containing the attribute.
+		identifier : str
+			The attribute name to test.
+
+		Returns
+		-------
+		predicate : Callable[[ast.AST], TypeIs[ast.If]]
+			A predicate function that returns `True` for `If` nodes with the specified test condition.
 
-		Returns:
-			A predicate function that returns True for If nodes with the specified test condition
 		"""
-		return lambda node: (Be.If(node)
-					and IfThis.isAttributeNamespaceIdentifierGreaterThan0(namespace, identifier)(DOT.test(node)))
+		return Be.If.testIs(IfThis.isAttributeNamespaceIdentifierGreaterThan0(namespace, identifier))
 
 	@staticmethod
-	def isWhileAttributeNamespaceIdentifierGreaterThan0(namespace: str, identifier: str) -> Callable[[ast.AST], TypeGuard[ast.While] | bool]:
-		"""
-		Generate a predicate that matches While loops testing if a namespaced attribute is greater than 0.
+	def isWhileAttributeNamespaceIdentifierGreaterThan0(namespace: str, identifier: str) -> Callable[[ast.AST], TypeIs[ast.While]]:
+		"""Generate a predicate that matches While loops testing if a namespaced attribute is greater than 0.
+
+		(AI generated docstring)
 
 		This function creates a predicate that identifies AST nodes representing loop
 		statements of the form `while namespace.identifier > 0:`. It's used to find
 		iteration constructs that continue while specific attributes remain positive.
 
-		Parameters:
-			namespace: The namespace or object name containing the attribute
-			identifier: The attribute name to test
-
-		Returns:
-			A predicate function that returns True for While nodes with the specified test condition
-		"""
-		return lambda node: (Be.While(node)
-					and IfThis.isAttributeNamespaceIdentifierGreaterThan0(namespace, identifier)(DOT.test(node)))
-	@staticmethod
-	def isAttributeNamespaceIdentifierLessThanOrEqual0(namespace: str, identifier: str) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
-		"""
-		Generate a predicate that matches comparison expressions testing if a namespaced attribute is less than or equal to 0.
-
-		This function creates a predicate that identifies AST nodes representing comparisons
-		of the form `namespace.identifier <= 0`. It's used to identify conditional
-		expressions that test non-positive values of counting variables or similar constructs.
+		Parameters
+		----------
+		namespace : str
+			The namespace or object name containing the attribute.
+		identifier : str
+			The attribute name to test.
 
-		Parameters:
-			namespace: The namespace or object name containing the attribute
-			identifier: The attribute name to test
+		Returns
+		-------
+		predicate : Callable[[ast.AST], TypeIs[ast.While]]
+			A predicate function that returns `True` for `While` nodes with the specified test condition.
 
-		Returns:
-			A predicate function that returns True for Compare nodes matching the pattern
 		"""
-		return lambda node: (Be.Compare(node)
-					and IfThis.isAttributeNamespaceIdentifier(namespace, identifier)(DOT.left(node))
-					and Be.LtE(node.ops[0]))
+		return Be.While.testIs(IfThis.isAttributeNamespaceIdentifierGreaterThan0(namespace, identifier))

mapFolding/someAssemblyRequired/_toolkitContainers.py

@@ -25,15 +25,12 @@ to low-level optimized functions while maintaining semantic equivalence and type
 the compilation process.
 """
 
-from astToolkit import (
-	ClassIsAndAttribute, DOT, hasDOTtarget_NameOrAttributeOrSubscript, identifierDotAttribute,
-	LedgerOfImports, Make, NodeTourist, Then,
-)
+from astToolkit import Be, DOT, identifierDotAttribute, LedgerOfImports, Make, NodeTourist, Then
 from collections.abc import Callable
 from copy import deepcopy
+from hunterMakesPy import raiseIfNone
 from mapFolding.someAssemblyRequired import IfThis
 from typing import Any, cast
-from Z0Z_tools import raiseIfNone
 import ast
 import dataclasses
 
@@ -43,8 +40,7 @@ dummyTuple = Make.Tuple([Make.Name("dummyElement")])
 
 @dataclasses.dataclass
 class ShatteredDataclass:
-	"""
-	Container for decomposed dataclass components organized as AST nodes for code generation.
+	"""Container for decomposed dataclass components organized as AST nodes for code generation.
 
 	This class holds the decomposed representation of a dataclass, breaking it down into individual
 	AST components that can be manipulated and recombined for different code generation contexts.
@@ -59,6 +55,7 @@ class ShatteredDataclass:
 	dataclass fields into individual parameters) and result reconstruction (packing individual
 	values back into dataclass instances).
 	"""
+
 	countingVariableAnnotation: ast.expr
 	"""Type annotation for the counting variable extracted from the dataclass."""
 
@@ -194,11 +191,16 @@ class DeReConstructField2ast:
 		scalar types, and complex type annotations, creating appropriate constructor
 		calls and import requirements.
 
-		Parameters:
-			dataclassesDOTdataclassLogicalPathModule: Module path containing the dataclass
-			dataclassClassDef: AST class definition for type annotation extraction
-			dataclassesDOTdataclassInstanceIdentifier: Instance variable name for attribute access
-			field: Dataclass field to transform
+		Parameters
+		----------
+		dataclassesDOTdataclassLogicalPathModule : identifierDotAttribute
+			Module path containing the dataclass
+		dataclassClassDef : ast.ClassDef
+			AST class definition for type annotation extraction
+		dataclassesDOTdataclassInstanceIdentifier : str
+			Instance variable name for attribute access
+		field : dataclasses.Field[Any]
+			Dataclass field to transform
 		"""
 		self.compare = field.compare
 		self.default = field.default if field.default is not dataclasses.MISSING else None
@@ -215,9 +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)
 
-		findThis=ClassIsAndAttribute.targetIs(ast.AnnAssign, IfThis.isNameIdentifier(self.name))
-		doThat=cast(Callable[[hasDOTtarget_NameOrAttributeOrSubscript], ast.expr], Then.extractIt(DOT.annotation))
-		self.astAnnotation = raiseIfNone(NodeTourist(findThis, doThat).captureLastMatch(dataclassClassDef))
+		self.astAnnotation = raiseIfNone(NodeTourist[ast.AnnAssign, ast.Name | None](
+			findThis = Be.AnnAssign.targetIs(IfThis.isNameIdentifier(self.name))
+			, doThat = Then.extractIt(cast("Callable[[ast.AnnAssign], ast.Name | None]", DOT.annotation))
+			).captureLastMatch(dataclassClassDef))
 
 		self.ast_argAnnotated = Make.arg(self.name, self.astAnnotation)
 
@@ -228,7 +231,7 @@ class DeReConstructField2ast:
 			self.ledger.addImportFrom_asStr(moduleWithLogicalPath, annotationType)
 			self.ledger.addImportFrom_asStr(moduleWithLogicalPath, 'dtype')
 			axesSubscript = Make.Subscript(Make.Name('tuple'), Make.Name('uint8'))
-			dtype_asnameName: ast.Name = cast(ast.Name, self.astAnnotation)
+			dtype_asnameName: ast.Name = self.astAnnotation
 			if dtype_asnameName.id == 'Array3D':
 				axesSubscript = Make.Subscript(Make.Name('tuple'), Make.Tuple([Make.Name('uint8'), Make.Name('uint8'), Make.Name('uint8')]))
 			ast_expr = Make.Subscript(Make.Name(annotationType), Make.Tuple([axesSubscript, Make.Subscript(Make.Name('dtype'), dtype_asnameName)]))

mapFolding/someAssemblyRequired/getLLVMforNoReason.py

@@ -24,34 +24,43 @@ While originally part of a tighter integration with the code generation assembly
 this module now operates as a standalone utility that can be applied to any module
 containing Numba-compiled functions.
 """
-from importlib.machinery import ModuleSpec
 from pathlib import Path
-from types import ModuleType
+from typing import TYPE_CHECKING
 import importlib.util
 import llvmlite.binding
 
+if TYPE_CHECKING:
+	from importlib.machinery import ModuleSpec
+	from types import ModuleType
+
 def writeModuleLLVM(pathFilename: Path, identifierCallable: str) -> Path:
-    """Import the generated module directly and get its LLVM IR.
-
-    Parameters
-        pathFilename: Path to the Python module file containing the Numba-compiled function
-        identifierCallable: Name of the function within the module to extract LLVM IR from
-
-    Returns
-        Path to the generated .ll file containing the extracted LLVM IR
-
-    For an example of the output, see reference/jobsCompleted/[2x19]/[2x19].ll,
-    which contains the IR for the historically significant 2x19 map calculation.
-    """
-    specTarget: ModuleSpec | None = importlib.util.spec_from_file_location("generatedModule", pathFilename)
-    if specTarget is None or specTarget.loader is None:
-        raise ImportError(f"Could not create module spec or loader for {pathFilename}")
-    moduleTarget: ModuleType = importlib.util.module_from_spec(specTarget)
-    specTarget.loader.exec_module(moduleTarget)
-
-    # Get LLVM IR and write to file
-    linesLLVM = moduleTarget.__dict__[identifierCallable].inspect_llvm()[()]
-    moduleLLVM: llvmlite.binding.ModuleRef = llvmlite.binding.module.parse_assembly(linesLLVM)
-    pathFilenameLLVM: Path = pathFilename.with_suffix(".ll")
-    pathFilenameLLVM.write_text(str(moduleLLVM))
-    return pathFilenameLLVM
+	"""Import the generated module directly and get its LLVM IR.
+
+	Parameters
+	----------
+	pathFilename : Path
+		Path to the Python module file containing the Numba-compiled function
+	identifierCallable : str
+		Name of the function within the module to extract LLVM IR from
+
+	Returns
+	-------
+	pathFilenameLLVM : Path
+		Path to the generated .ll file containing the extracted LLVM IR
+
+	For an example of the output, see reference/jobsCompleted/[2x19]/[2x19].ll,
+	which contains the IR for the historically significant 2x19 map calculation.
+	"""
+	specTarget: ModuleSpec | None = importlib.util.spec_from_file_location("generatedModule", pathFilename)
+	if specTarget is None or specTarget.loader is None:
+		message = f"Could not create module spec or loader for {pathFilename}"
+		raise ImportError(message)
+	moduleTarget: ModuleType = importlib.util.module_from_spec(specTarget)
+	specTarget.loader.exec_module(moduleTarget)
+
+	# Get LLVM IR and write to file
+	linesLLVM = moduleTarget.__dict__[identifierCallable].inspect_llvm()[()]
+	moduleLLVM: llvmlite.binding.ModuleRef = llvmlite.binding.module.parse_assembly(linesLLVM)
+	pathFilenameLLVM: Path = pathFilename.with_suffix(".ll")
+	pathFilenameLLVM.write_text(str(moduleLLVM))
+	return pathFilenameLLVM