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

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