mapFolding 0.8.4__py3-none-any.whl → 0.8.5__py3-none-any.whl

mapFolding/someAssemblyRequired/_toolboxAntecedents.py

@@ -1,9 +1,65 @@
 from collections.abc import Callable, Container
-from mapFolding.someAssemblyRequired import ast_expr_Slice, ast_Identifier, astClassHasDOTnameNotName, astClassHasDOTtarget, astClassHasDOTvalue, ImaAnnotationType, typeCertified
-from typing import Any, overload, TypeGuard
+from mapFolding.someAssemblyRequired import (
+	ast_expr_Slice,
+	ast_Identifier,
+	Ima_funcTypeUNEDITED,
+	astClassHasDOTnameNotName,
+	astClassOptionallyHasDOTnameNotName,
+	astClassHasDOTtarget,
+	astClassHasDOTvalue,
+	ImaAnnotationType,
+	ImaAnnotationTypeVar,
+	Ima_targetTypeUNEDITED,
+	TypeCertified,
+)
+from typing import Any, cast, overload, TypeGuard
 import ast
 
-Ima_targetType = ast.AST
+class NotMyProblem(Exception):
+	pass
+
+class DOT:
+	@staticmethod
+	@overload
+	def annotation(node: ast.AnnAssign) -> ImaAnnotationType:...
+	@staticmethod
+	@overload
+	def annotation(node: ast.arg) -> ImaAnnotationType | None:...
+	@staticmethod
+	def annotation(node: ast.AnnAssign | ast.arg) -> ImaAnnotationType | None:
+		return cast(ImaAnnotationType, node.annotation)
+		# fu = node.annotation
+		# if fu is None:
+		# 	return None
+		# else:
+		# 	fu = cast(ImaAnnotationType, node.annotation)
+		# 	return fu
+	@staticmethod
+	def func(node: ast.Call) -> Ima_funcTypeUNEDITED | ast.expr:
+		return node.func
+	@staticmethod
+	def id(node: ast.Name) -> ast_Identifier:
+		return node.id
+	@staticmethod
+	def name(node: astClassHasDOTnameNotName | astClassOptionallyHasDOTnameNotName) -> ast_Identifier:
+		if isinstance(node, astClassHasDOTnameNotName):
+			return node.name
+		try:
+			identifier = node.name
+			if identifier is None:
+				raise NotMyProblem
+			return identifier
+		except AttributeError:
+			raise NotMyProblem
+
+	@staticmethod
+	def nameOrNone(node: astClassHasDOTnameNotName | astClassOptionallyHasDOTnameNotName) -> ast_Identifier | None:
+		if isinstance(node, astClassHasDOTnameNotName):
+			return node.name
+		try:
+			return node.name
+		except AttributeError:
+			return None
 
 class 又:
 	@staticmethod
@@ -76,79 +132,64 @@ class 又:
 
 class be:
 	@staticmethod
-	def _typeCertified(antecedent: type[typeCertified]) -> Callable[[Any | None], TypeGuard[typeCertified]]:
-		def workhorse(node: Any | None) -> TypeGuard[typeCertified]:
+	def _typeCertified(antecedent: type[TypeCertified]) -> Callable[[Any | None], TypeGuard[TypeCertified]]:
+		def workhorse(node: Any | None) -> TypeGuard[TypeCertified]:
 			return isinstance(node, antecedent)
 		return workhorse
 	@staticmethod
-	def AnnAssign(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.AnnAssign)(node)
-# 'TypeVar "typeCertified" appears only once in generic function signature. Use "object" instead Pylance(reportInvalidTypeVarUse)"' HOW THE FUCK IS THAT INVALID WHEN IT IS WORKING PERFECTLY TO PASS THE TYPE INFORMATION--IN YOUR FUCKING STATIC TYPE CHECKER, PYLANCE!!!! Fuck you, and fuck your pretentious language.
+	def AnnAssign(node: TypeCertified) -> TypeGuard[ast.AnnAssign]: return be._typeCertified(ast.AnnAssign)(node) # pyright: ignore [reportInvalidTypeVarUse]
+# 'TypeVar "typeCertified" appears only once in generic function signature. Use "typeCertified" instead Pylance(reportInvalidTypeVarUse)"' HOW THE FUCK IS THAT INVALID WHEN IT IS WORKING PERFECTLY TO PASS THE TYPE INFORMATION--IN YOUR FUCKING STATIC TYPE CHECKER, PYLANCE!!!! Fuck you, and fuck your pretentious language.
 	@staticmethod
-	def arg(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.arg)(node)
-
-	# @staticmethod
-	# def Annotation(node: ast.AST) -> TypeGuard[object] | bool:
-	# 	if be.Attribute(node):
-	# 		return be.Attribute(node)
-	# 	elif be.Constant(node):
-	# 		return be.Constant(node)
-	# 	elif be.Name(node):
-	# 		return be.Name(node)
-	# 	elif be.Subscript(node):
-	# 		return be.Subscript(node)
-	# 	else:
-	# 		return False
-		# return be.Attribute(node) or be.Constant(node) or be.Name(node) or be.Subscript(node)
-
+	def arg(node: TypeCertified) -> TypeGuard[ast.arg]: return be._typeCertified(ast.arg)(node) # pyright: ignore [reportInvalidTypeVarUse]
 	@staticmethod
-	def Assign(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.Assign)(node)
+	def Assign(node: TypeCertified) -> TypeGuard[ast.Assign]: return be._typeCertified(ast.Assign)(node) # pyright: ignore [reportInvalidTypeVarUse]
 	@staticmethod
-	def Attribute(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.Attribute)(node)
+	def Attribute(node: TypeCertified) -> TypeGuard[ast.Attribute]: return be._typeCertified(ast.Attribute)(node) # pyright: ignore [reportInvalidTypeVarUse]
 	@staticmethod
-	def AugAssign(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.AugAssign)(node)
+	def AugAssign(node: TypeCertified) -> TypeGuard[ast.AugAssign]: return be._typeCertified(ast.AugAssign)(node) # pyright: ignore [reportInvalidTypeVarUse]
 	@staticmethod
-	def BoolOp(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.BoolOp)(node)
+	def BoolOp(node: TypeCertified) -> TypeGuard[ast.BoolOp]: return be._typeCertified(ast.BoolOp)(node) # pyright: ignore [reportInvalidTypeVarUse]
 	@staticmethod
-	def Call(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.Call)(node)
+	def Call(node: TypeCertified) -> TypeGuard[ast.Call]: return be._typeCertified(ast.Call)(node) # pyright: ignore [reportInvalidTypeVarUse]
 	@staticmethod
-	def ClassDef(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.ClassDef)(node)
+	def ClassDef(node: TypeCertified) -> TypeGuard[ast.ClassDef]: return be._typeCertified(ast.ClassDef)(node) # pyright: ignore [reportInvalidTypeVarUse]
 	@staticmethod
-	def Compare(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.Compare)(node)
+	def Compare(node: TypeCertified) -> TypeGuard[ast.Compare]: return be._typeCertified(ast.Compare)(node) # pyright: ignore [reportInvalidTypeVarUse]
 	@staticmethod
-	def Constant(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.Constant)(node)
+	def Constant(node: TypeCertified) -> TypeGuard[ast.Constant]: return be._typeCertified(ast.Constant)(node) # pyright: ignore [reportInvalidTypeVarUse]
 	@staticmethod
-	def Expr(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.Expr)(node)
+	def Expr(node: TypeCertified) -> TypeGuard[ast.Expr]: return be._typeCertified(ast.Expr)(node) # pyright: ignore [reportInvalidTypeVarUse]
 	@staticmethod
-	def FunctionDef(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.FunctionDef)(node)
+	def FunctionDef(node: TypeCertified) -> TypeGuard[ast.FunctionDef]: return be._typeCertified(ast.FunctionDef)(node) # pyright: ignore [reportInvalidTypeVarUse]
 	@staticmethod
-	def Import(node: ast.AST) -> TypeGuard[ast.Import]: return be._typeCertified(ast.Import)(node)
+	def Import(node: TypeCertified) -> TypeGuard[ast.Import]: return be._typeCertified(ast.Import)(node) # pyright: ignore [reportInvalidTypeVarUse]
 	@staticmethod
-	def ImportFrom(node: ast.AST) -> TypeGuard[ast.ImportFrom]: return be._typeCertified(ast.ImportFrom)(node)
+	def ImportFrom(node: TypeCertified) -> TypeGuard[ast.ImportFrom]: return be._typeCertified(ast.ImportFrom)(node) # pyright: ignore [reportInvalidTypeVarUse]
 	@staticmethod
-	def keyword(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.keyword)(node)
+	def keyword(node: TypeCertified) -> TypeGuard[ast.keyword]: return be._typeCertified(ast.keyword)(node) # pyright: ignore [reportInvalidTypeVarUse]
 	@staticmethod
-	def Module(node: ast.AST) -> TypeGuard[typeCertified]: return be._typeCertified(ast.Module)(node)
+	def Module(node: TypeCertified) -> TypeGuard[ast.Module]: return be._typeCertified(ast.Module)(node) # pyright: ignore [reportInvalidTypeVarUse]
 	@staticmethod
-	def Name(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.Name)(node)
+	def Name(node: TypeCertified) -> TypeGuard[ast.Name]: return be._typeCertified(ast.Name)(node) # pyright: ignore [reportInvalidTypeVarUse]
 	@staticmethod
-	def Return(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.Return)(node)
+	def Return(node: TypeCertified) -> TypeGuard[ast.Return]: return be._typeCertified(ast.Return)(node) # pyright: ignore [reportInvalidTypeVarUse]
 	@staticmethod
-	def Starred(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.Starred)(node)
+	def Starred(node: TypeCertified) -> TypeGuard[ast.Starred]: return be._typeCertified(ast.Starred)(node) # pyright: ignore [reportInvalidTypeVarUse]
 	@staticmethod
-	def Subscript(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.Subscript)(node)
+	def Subscript(node: TypeCertified) -> TypeGuard[ast.Subscript]: return be._typeCertified(ast.Subscript)(node) # pyright: ignore [reportInvalidTypeVarUse]
 	@staticmethod
-	def UnaryOp(node: ast.AST) -> TypeGuard[object]: return be._typeCertified(ast.UnaryOp)(node)
+	def UnaryOp(node: TypeCertified) -> TypeGuard[ast.UnaryOp]: return be._typeCertified(ast.UnaryOp)(node) # pyright: ignore [reportInvalidTypeVarUse]
 
 class ifThis:
 	@staticmethod
 	def equals(this: Any) -> Callable[[Any], TypeGuard[Any] | bool]:
 		return lambda node: node == this
 	@staticmethod
-	def isAssignAndTargets0Is(targets0Predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+	def isAssignAndTargets0Is(targets0Predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], TypeGuard[ast.AnnAssign] | bool]:
 		"""node is Assign and node.targets[0] matches `targets0Predicate`."""
 		return lambda node: be.Assign(node) and targets0Predicate(node.targets[0])
 	@staticmethod
-	def isAssignAndValueIs(valuePredicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+	def isAssignAndValueIs(valuePredicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], TypeGuard[ast.Assign] | bool]:
 		"""node is ast.Assign and node.value matches `valuePredicate`.
 		Parameters:
 			valuePredicate: Function that evaluates the value of the assignment
@@ -157,101 +198,92 @@ class ifThis:
 		"""
 		return lambda node: be.Assign(node) and 又.value(valuePredicate)(node)
 	@staticmethod
-	def isFunctionDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+	def isFunctionDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.FunctionDef] | bool]:
 		return lambda node: be.FunctionDef(node) and 又.name(ifThis._Identifier(identifier))(node)
 	@staticmethod
-	def isArgument_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+	def isArgument_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.arg | ast.keyword] | bool]:
 		return lambda node: (be.arg(node) or be.keyword(node)) and 又.arg(ifThis._Identifier(identifier))(node)
 	@staticmethod
-	def is_keyword_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+	def is_keyword_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.keyword] | bool]:
 		"""see also `isArgument_Identifier`"""
 		return lambda node: be.keyword(node) and 又.arg(ifThis._Identifier(identifier))(node)
 	@staticmethod
-	def is_arg_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+	def is_arg_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.arg] | bool]:
 		"""see also `isArgument_Identifier`"""
 		return lambda node: be.arg(node) and 又.arg(ifThis._Identifier(identifier))(node)
 	@staticmethod
-	def isClassDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+	def isClassDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.ClassDef] | bool]:
 		return lambda node: be.ClassDef(node) and 又.name(ifThis._Identifier(identifier))(node)
 	@staticmethod
-	def isAssignAndValueIsCall_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+	def isAssignAndValueIsCall_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Assign] | bool]:
 		return lambda node: be.Assign(node) and 又.value(ifThis.isCall_Identifier(identifier))(node)
 	@staticmethod
-	def isAssignAndValueIsCallAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+	def isAssignAndValueIsCallAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Assign] | bool]:
 		return ifThis.isAssignAndValueIs(ifThis.isCallAttributeNamespace_Identifier(namespace, identifier))
 	@staticmethod
-	def is_keywordAndValueIsConstant(node: ast.AST) -> TypeGuard[object]:
+	def is_keywordAndValueIsConstant(node: TypeCertified) -> TypeGuard[ast.keyword]: # pyright: ignore [reportInvalidTypeVarUse]
 		return be.keyword(node) and 又.value(be.Constant)(node)
 	@staticmethod
-	def is_keyword_IdentifierEqualsConstantValue(identifier: ast_Identifier, ConstantValue: Any) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+	def is_keyword_IdentifierEqualsConstantValue(identifier: ast_Identifier, ConstantValue: Any) -> Callable[[ast.AST], TypeGuard[ast.keyword] | bool]:
 		return lambda node: ifThis.is_keyword_Identifier(identifier)(node) and ifThis.is_keywordAndValueIsConstant(node) and 又.value(ifThis.isConstantEquals(ConstantValue))(node)
-	"""
-Argument of type "typeCertified@isAnnAssign_targetIs" cannot be assigned to parameter of type "astClassHasDOTtarget"
-	Type "typeCertified@isAnnAssign_targetIs" is not assignable to type "astClassHasDOTtarget"
-		"object*" is not assignable to "AnnAssign"
-		"object*" is not assignable to "AsyncFor"
-		"object*" is not assignable to "AugAssign"
-		"object*" is not assignable to "comprehension"
-		"object*" is not assignable to "For"
-		"object*" is not assignable to "NamedExpr"
-	"""
-	@staticmethod
-	def isAnnAssign_targetIs(targetPredicate: Callable[[Ima_targetType], TypeGuard[Ima_targetType] | bool]) -> Callable[[ast.AST], TypeGuard[object] | bool]:
-		def workhorse(node: ast.AST) -> TypeGuard[object] | bool:
+	@staticmethod
+	def isAnnAssign_targetIs(targetPredicate: Callable[[Ima_targetTypeUNEDITED], TypeGuard[Ima_targetTypeUNEDITED] | bool]) -> Callable[[ast.AST], TypeGuard[ast.AnnAssign] | bool]:
+		def workhorse(node: TypeCertified) -> TypeGuard[ast.AnnAssign] | bool: # pyright: ignore [reportInvalidTypeVarUse]
 			return be.AnnAssign(node) and 又.target(targetPredicate)(node)
 		return workhorse
 	@staticmethod
-	def isAnnAssignAndAnnotationIsName(node: ast.AST) -> TypeGuard[object] | bool:
-		return be.AnnAssign(node) and 又.annotation(be.Name)(node)
+	def isAnnAssignAndAnnotationIsName(node: TypeCertified) -> TypeGuard[ast.AnnAssign] | bool: # pyright: ignore [reportInvalidTypeVarUse]
+		return be.AnnAssign(node) and be.Name(DOT.annotation(node))
+		# return be.AnnAssign(node) and 又.annotation(be.Name)(node)
 	@staticmethod
-	def isAugAssign_targetIs(targetPredicate: Callable[[Ima_targetType], TypeGuard[Ima_targetType] | bool]) -> Callable[[ast.AST], TypeGuard[typeCertified] | bool]:
-		def workhorse(node: ast.AST) -> TypeGuard[typeCertified] | bool:
+	def isAugAssign_targetIs(targetPredicate: Callable[[Ima_targetTypeUNEDITED], TypeGuard[Ima_targetTypeUNEDITED] | bool]) -> Callable[[ast.AST], TypeGuard[ast.AugAssign] | bool]:
+		def workhorse(node: TypeCertified) -> TypeGuard[ast.AugAssign] | bool: # pyright: ignore [reportInvalidTypeVarUse]
 			return be.AugAssign(node) and 又.target(targetPredicate)(node)
 		return workhorse
 
 	@staticmethod
-	def isAnyCompare(node: ast.AST) -> TypeGuard[object]:
+	def isAnyCompare(node: TypeCertified) -> TypeGuard[ast.BoolOp | ast.Compare]: # pyright: ignore [reportInvalidTypeVarUse]
 		return be.Compare(node) or be.BoolOp(node)
 	@staticmethod
-	def isConstantEquals(value: Any) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+	def isConstantEquals(value: Any) -> Callable[[ast.AST], TypeGuard[ast.Constant] | bool]:
 		return lambda node: be.Constant(node) and 又.value(ifThis.equals(value))(node)
 	@staticmethod
-	def isReturnAnyCompare(node: ast.AST) -> TypeGuard[object] | bool:
+	def isReturnAnyCompare(node: TypeCertified) -> TypeGuard[ast.Return] | bool: # pyright: ignore [reportInvalidTypeVarUse] # pyright: ignore [reportInvalidTypeVarUse]
 		return be.Return(node) and 又.value(ifThis.isAnyCompare)(node)
 	@staticmethod
-	def isReturnUnaryOp(node: ast.AST) -> TypeGuard[object] | bool:
+	def isReturnUnaryOp(node: TypeCertified) -> TypeGuard[ast.Return] | bool: # pyright: ignore [reportInvalidTypeVarUse]
 		return be.Return(node) and 又.value(be.UnaryOp)(node)
 
 	# ================================================================
 	# Nested identifier
 	@staticmethod
-	def _nestedJunction_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
-		def workhorse(node: ast.AST) -> TypeGuard[object] | bool:
+	def _nestedJunction_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Attribute | ast.Starred | ast.Subscript] | bool]:
+		def workhorse(node: TypeCertified) -> TypeGuard[ast.Attribute | ast.Starred | ast.Subscript] | bool: # pyright: ignore [reportInvalidTypeVarUse]
 			return ifThis.isName_Identifier(identifier)(node) or ifThis.isAttribute_Identifier(identifier)(node) or ifThis.isSubscript_Identifier(identifier)(node) or ifThis.isStarred_Identifier(identifier)(node)
 		return workhorse
 	@staticmethod
-	def isAttribute_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+	def isAttribute_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Attribute] | bool]:
 		"""node is `ast.Attribute` and the top-level `ast.Name` is `identifier`"""
-		def workhorse(node: ast.AST) -> TypeGuard[object]:
+		def workhorse(node: TypeCertified) -> TypeGuard[ast.Attribute]: # pyright: ignore [reportInvalidTypeVarUse]
 			return be.Attribute(node) and 又.value(ifThis._nestedJunction_Identifier(identifier))(node)
 		return workhorse
 	@staticmethod
-	def isStarred_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+	def isStarred_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Starred] | bool]:
 		"""node is `ast.Starred` and the top-level `ast.Name` is `identifier`"""
-		def workhorse(node: ast.AST) -> TypeGuard[object]:
+		def workhorse(node: TypeCertified) -> TypeGuard[ast.Starred]: # pyright: ignore [reportInvalidTypeVarUse]
 			return be.Starred(node) and 又.value(ifThis._nestedJunction_Identifier(identifier))(node)
 		return workhorse
 	@staticmethod
-	def isSubscript_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+	def isSubscript_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Subscript] | bool]:
 		"""node is `ast.Subscript` and the top-level `ast.Name` is `identifier`"""
-		def workhorse(node: ast.AST) -> TypeGuard[object]:
+		def workhorse(node: TypeCertified) -> TypeGuard[ast.Subscript]: # pyright: ignore [reportInvalidTypeVarUse]
 			return be.Subscript(node) and 又.value(ifThis._nestedJunction_Identifier(identifier))(node)
 		return workhorse
 	# ================================================================
 
 	@staticmethod
 	def Z0Z_unparseIs(astAST: ast.AST) -> Callable[[ast.AST], bool]:
-		def workhorse(node: ast.AST) -> bool: return ast.unparse(node) == ast.unparse(astAST)
+		def workhorse(node: TypeCertified) -> bool: return ast.unparse(node) == ast.unparse(astAST) # pyright: ignore [reportInvalidTypeVarUse]
 		return workhorse
 
 	# ================================================================
@@ -264,32 +296,36 @@ Argument of type "typeCertified@isAnnAssign_targetIs" cannot be assigned to para
 	# ================================================================
 	# MORE function inlining
 	@staticmethod
-	def onlyReturnAnyCompare(astFunctionDef: ast.AST) -> TypeGuard[object]:
+	def onlyReturnAnyCompare(astFunctionDef: ast.AST) -> TypeGuard[ast.FunctionDef] | bool:
 		return be.FunctionDef(astFunctionDef) and len(astFunctionDef.body) == 1 and ifThis.isReturnAnyCompare(astFunctionDef.body[0])
 	# For function inlining
 	@staticmethod
-	def onlyReturnUnaryOp(astFunctionDef: ast.AST) -> TypeGuard[object]:
+	def onlyReturnUnaryOp(astFunctionDef: ast.AST) -> TypeGuard[ast.FunctionDef] | bool:
 		return be.FunctionDef(astFunctionDef) and len(astFunctionDef.body) == 1 and ifThis.isReturnUnaryOp(astFunctionDef.body[0])
 	# ================================================================
 	# These are used by other functions
 	@staticmethod
-	def isCallAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+	def isCallAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Call] | bool]:
 		return lambda node: be.Call(node) and 又.func(ifThis.isAttributeNamespace_Identifier(namespace, identifier))(node)
 	@staticmethod
-	def isName_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+	def isName_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Name] | bool]:
 		return lambda node: be.Name(node) and 又.id(ifThis._Identifier(identifier))(node)
 	@staticmethod
-	def isCall_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+	def isCall_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Call] | bool]:
 		return lambda node: be.Call(node) and 又.func(ifThis.isName_Identifier(identifier))(node)
 	# ================================================================
 	@staticmethod
+	def CallDoesNotCallItself(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Call] | bool]:
+		"""If `namespace` is not applicable to your case, then call with `namespace=""`."""
+		return lambda node: ifThis.matchesMeButNotAnyDescendant(ifThis.CallReallyIs(namespace, identifier))(node)
+	@staticmethod
 	def matchesMeButNotAnyDescendant(predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], bool]:
 		"""Create a predicate that returns True if the node matches but none of its descendants match the predicate."""
 		return lambda node: predicate(node) and ifThis.matchesNoDescendant(predicate)(node)
 	@staticmethod
 	def matchesNoDescendant(predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], bool]:
 		"""Create a predicate that returns True if no descendant of the node matches the given predicate."""
-		def workhorse(node: ast.AST) -> bool:
+		def workhorse(node: TypeCertified) -> bool: # pyright: ignore [reportInvalidTypeVarUse]
 			for descendant in ast.walk(node):
 				if descendant is not node and predicate(descendant):
 					return False
@@ -297,30 +333,26 @@ Argument of type "typeCertified@isAnnAssign_targetIs" cannot be assigned to para
 		return workhorse
 
 	@staticmethod
-	def CallDoesNotCallItself(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
-		"""If `namespace` is not applicable to your case, then call with `namespace=""`."""
-		return lambda node: ifThis.matchesMeButNotAnyDescendant(ifThis.CallReallyIs(namespace, identifier))(node)
-	@staticmethod
-	def CallReallyIs(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+	def CallReallyIs(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Call] | bool]:
 		return ifThis.isCall_Identifier(identifier) or ifThis.isCallAttributeNamespace_Identifier(namespace, identifier)
 	@staticmethod
-	def isAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[object] | bool]:
+	def isAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Attribute] | bool]:
 		return lambda node: ifThis.isAttributeName(node) and 又.value(ifThis.isName_Identifier(namespace))(node) and 又.attr(ifThis._Identifier(identifier))(node)
 	@staticmethod
 	def _Identifier(identifier: ast_Identifier) -> Callable[[ast_Identifier | None], TypeGuard[ast_Identifier] | bool]:
 		return lambda node: node == identifier
 	@staticmethod
-	def isAttributeName(node: ast.AST) -> TypeGuard[object]:
+	def isAttributeName(node: TypeCertified) -> TypeGuard[ast.Attribute]: # pyright: ignore [reportInvalidTypeVarUse]
 		""" Displayed as Name.attribute."""
 		return be.Attribute(node) and 又.value(be.Name)(node)
 
 	@staticmethod
-	def isCallToName(node: ast.AST) -> TypeGuard[object]:
+	def isCallToName(node: TypeCertified) -> TypeGuard[ast.Call]: # pyright: ignore [reportInvalidTypeVarUse]
 		return be.Call(node) and 又.func(be.Name)(node)
 	@staticmethod
 	def ast_IdentifierIn(container: Container[ast_Identifier]) -> Callable[[ast_Identifier], TypeGuard[ast_Identifier] | bool]:
 		return lambda node: node in container
 	# This bullshit is for the crappy function inliner I made.
 	@staticmethod
-	def CallDoesNotCallItselfAndNameDOTidIsIn(container: Container[ast_Identifier]) -> Callable[[ast.AST], TypeGuard[object] | bool]:
-		return lambda node: ifThis.isCallToName(node) and 又.func(又.id(ifThis.ast_IdentifierIn(container)))(node) and ifThis.CallDoesNotCallItself("", node.func.id)(node)
+	def CallDoesNotCallItselfAndNameDOTidIsIn(container: Container[ast_Identifier]) -> Callable[[ast.AST], TypeGuard[ast.Call] | bool]:
+		return lambda node: ifThis.isCallToName(node) and 又.func(又.id(ifThis.ast_IdentifierIn(container)))(node) and ifThis.CallDoesNotCallItself("", node.func.id)(node) # type: ignore

mapFolding/someAssemblyRequired/_toolboxContainers.py

@@ -7,8 +7,8 @@ circular imports while providing reusable data structures.
 """
 from collections import defaultdict
 from collections.abc import Sequence
-from mapFolding.someAssemblyRequired import ast_Identifier, be, ifThis, Make, parseLogicalPath2astModule, str_nameDOTname
-from mapFolding.theSSOT import callableDispatcherHARDCODED, raiseIfNoneGitHubIssueNumber3, The
+from mapFolding.someAssemblyRequired import ImaAnnotationType, ast_Identifier, be, Make, parseLogicalPath2astModule, str_nameDOTname
+from mapFolding.theSSOT import callableDispatcherHARDCODED, The
 from pathlib import Path, PurePosixPath
 from Z0Z_tools import updateExtendPolishDictionaryLists
 import ast
@@ -299,8 +299,36 @@ theLogicalPathModuleDispatcherSynthetic: str = '.'.join([The.packageName, The.mo
 		if self.callableDispatcher!=callableDispatcherHARDCODED:
 			print(f"fyi: `{self.callableDispatcher=}` but\n\t`{callableDispatcherHARDCODED=}`.")
 
-def astModuleToIngredientsFunction(astModule: ast.AST, identifierFunctionDef: ast_Identifier) -> IngredientsFunction:
-	from mapFolding.someAssemblyRequired import extractFunctionDef
-	astFunctionDef = extractFunctionDef(astModule, identifierFunctionDef)
-	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
-	return IngredientsFunction(astFunctionDef, LedgerOfImports(astModule))
+dummyAssign = Make.Assign([Make.Name("dummyTarget")], Make.Constant(None))
+dummySubscript = Make.Subscript(Make.Name("dummy"), Make.Name("slice"))
+dummyTuple = Make.Tuple([Make.Name("dummyElement")])
+
+@dataclasses.dataclass
+class ShatteredDataclass:
+	countingVariableAnnotation: ImaAnnotationType
+	"""Type annotation for the counting variable extracted from the dataclass."""
+	countingVariableName: ast.Name
+	"""AST name node representing the counting variable identifier."""
+	field2AnnAssign: dict[ast_Identifier, ast.AnnAssign] = dataclasses.field(default_factory=dict)
+	"""Maps field names to their corresponding AST call expressions."""
+	Z0Z_field2AnnAssign: dict[ast_Identifier, tuple[ast.AnnAssign, str]] = dataclasses.field(default_factory=dict)
+	fragments4AssignmentOrParameters: ast.Tuple = dummyTuple
+	"""AST tuple used as target for assignment to capture returned fragments."""
+	ledger: LedgerOfImports = dataclasses.field(default_factory=LedgerOfImports)
+	"""Import records for the dataclass and its constituent parts."""
+	list_argAnnotated4ArgumentsSpecification: list[ast.arg] = dataclasses.field(default_factory=list)
+	"""Function argument nodes with annotations for parameter specification."""
+	list_keyword_field__field4init: list[ast.keyword] = dataclasses.field(default_factory=list)
+	"""Keyword arguments for dataclass initialization with field=field format."""
+	listAnnotations: list[ImaAnnotationType] = dataclasses.field(default_factory=list)
+	"""Type annotations for each dataclass field."""
+	listName4Parameters: list[ast.Name] = dataclasses.field(default_factory=list)
+	"""Name nodes for each dataclass field used as function parameters."""
+	listUnpack: list[ast.AnnAssign] = dataclasses.field(default_factory=list)
+	"""Annotated assignment statements to extract fields from dataclass."""
+	map_stateDOTfield2Name: dict[ast.expr, ast.Name] = dataclasses.field(default_factory=dict)
+	"""Maps AST expressions to Name nodes for find-replace operations."""
+	repack: ast.Assign = dummyAssign
+	"""AST assignment statement that reconstructs the original dataclass instance."""
+	signatureReturnAnnotation: ast.Subscript = dummySubscript
+	"""tuple-based return type annotation for function definitions."""

mapFolding/someAssemblyRequired/_toolboxPython.py

@@ -1,57 +1,43 @@
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
 from inspect import getsource as inspect_getsource
-from mapFolding.someAssemblyRequired import ast_Identifier, str_nameDOTname
+from mapFolding.someAssemblyRequired import ast_Identifier, str_nameDOTname, 个
 from os import PathLike
 from pathlib import Path, PurePath
 from types import ModuleType
-from typing import Any, Literal
+from typing import Any, cast, Generic, TypeGuard
 import ast
 import importlib
 import importlib.util
 
 # TODO Identify the logic that narrows the type and can help the user during static type checking.
 
-class NodeTourist(ast.NodeVisitor):
-    def __init__(self, findThis, doThat): # type: ignore
+class NodeTourist(ast.NodeVisitor, Generic[个]):
+    def __init__(self, findThis: Callable[[个], TypeGuard[个] | bool], doThat: Callable[[个], 个 | None]) -> None:
         self.findThis = findThis
         self.doThat = doThat
-        self.nodeCaptured = None
+        self.nodeCaptured: 个 | None = None
 
-    def visit(self, node): # type: ignore
+    def visit(self, node: 个) -> None: # pyright: ignore [reportGeneralTypeIssues]
         if self.findThis(node):
-            nodeActionReturn = self.doThat(node) # type: ignore
+            nodeActionReturn = self.doThat(node)
             if nodeActionReturn is not None:
-                self.nodeCaptured = nodeActionReturn # type: ignore
-        self.generic_visit(node)
-
-    def captureLastMatch(self, node): # type: ignore
-        """Capture the last matched node that produces a non-None result.
-
-        This method traverses the entire tree starting at the given node
-        and returns the last non-None value produced by applying doThat
-        to a matching node. It will continue traversing after finding a match,
-        and the value captured can be replaced by later matches.
-
-        Parameters:
-            node: The AST node to start traversal from
+                self.nodeCaptured = nodeActionReturn
+        self.generic_visit(cast(ast.AST, node))
 
-        Returns:
-            The result of applying doThat to the last matching node that returned
-            a non-None value, or None if no match found or all matches returned None
-        """
+    def captureLastMatch(self, node: 个) -> 个 | None: # pyright: ignore [reportGeneralTypeIssues]
         self.nodeCaptured = None
-        self.visit(node) # type: ignore
+        self.visit(node)
         return self.nodeCaptured
 
-class NodeChanger(ast.NodeTransformer):
-    def __init__(self, findThis, doThat): # type: ignore
+class NodeChanger(ast.NodeTransformer, Generic[个]):
+    def __init__(self, findThis: Callable[[个], bool], doThat: Callable[[个], Sequence[个] | 个 | None]) -> None:
         self.findThis = findThis
         self.doThat = doThat
 
-    def visit(self, node): # type: ignore
+    def visit(self, node: 个) -> Sequence[个] | 个 | None: # pyright: ignore [reportGeneralTypeIssues]
         if self.findThis(node):
-            return self.doThat(node) # type: ignore
-        return super().visit(node)
+            return self.doThat(node)
+        return super().visit(cast(ast.AST, node))
 
 def importLogicalPath2Callable(logicalPathModule: str_nameDOTname, identifier: ast_Identifier, packageIdentifierIfRelative: ast_Identifier | None = None) -> Callable[..., Any]:
     moduleImported: ModuleType = importlib.import_module(logicalPathModule, packageIdentifierIfRelative)

mapFolding/someAssemblyRequired/getLLVMforNoReason.py

@@ -18,9 +18,9 @@ mapFolding/reference/jobsCompleted/[2x19]/[2x19].ll
 
 This file demonstrates the low-level optimizations that made this previously
 intractable calculation possible. The IR reveals how the abstract algorithm was
-transformed into efficient machine code through Numba's compilation pipeline.
+transformed into efficient machine code through Numba's compilation assembly-line.
 
-While originally part of a tighter integration with the code generation pipeline,
+While originally part of a tighter integration with the code generation assembly-line,
 this module now operates as a standalone utility that can be applied to any module
 containing Numba-compiled functions.
 """

mapFolding/someAssemblyRequired/newInliner.py

@@ -0,0 +1,22 @@
+from collections.abc import Callable
+from copy import deepcopy
+from mapFolding.someAssemblyRequired import ast_Identifier, RecipeSynthesizeFlow, Then, be, ifThis, DOT, 又, NodeChanger
+from mapFolding.someAssemblyRequired.transformationTools import makeDictionary4InliningFunction, makeDictionaryFunctionDef
+from typing import cast
+import ast
+
+def inlineFunctionDef(astFunctionDef: ast.FunctionDef, dictionary4Inlining: dict[ast_Identifier, ast.FunctionDef]) -> ast.FunctionDef:
+
+	return astFunctionDef
+
+# Test code
+testFlow: RecipeSynthesizeFlow = RecipeSynthesizeFlow()
+dictionary4Inlining: dict[ast_Identifier, ast.FunctionDef] = makeDictionary4InliningFunction(
+	testFlow.sourceCallableSequential,
+	(dictionaryFunctionDef := makeDictionaryFunctionDef(testFlow.source_astModule)))
+
+astFunctionDef = dictionaryFunctionDef[testFlow.sourceCallableSequential]
+
+astFunctionDefTransformed = inlineFunctionDef(
+	astFunctionDef,
+	dictionary4Inlining)