mapFolding 0.9.5__py3-none-any.whl → 0.11.0__py3-none-any.whl

mapFolding/someAssemblyRequired/_tool_Then.py

@@ -1,152 +0,0 @@
-"""
-AST Node Transformation Actions for Python Code Manipulation
-
-This module provides the Then class with static methods for generating callable action functions that specify what to do
-with AST nodes that match predicates. These action functions are used primarily with NodeChanger and NodeTourist to
-transform or extract information from AST nodes.
-
-The module also contains the grab class that provides functions for modifying specific attributes of AST nodes while
-preserving their structure, enabling fine-grained control when transforming AST structures.
-
-Together, these classes provide a complete system for manipulating AST nodes once they have been identified using
-predicate functions from ifThis.
-"""
-
-from collections.abc import Callable, Sequence
-from mapFolding.someAssemblyRequired import ast_Identifier, astClassHasDOTvalue, ImaCallToName, NodeORattribute
-from typing import Any
-import ast
-
-class grab:
-	"""
-	Modify specific attributes of AST nodes while preserving the node structure.
-
-	The grab class provides static methods that create transformation functions to modify specific attributes of AST
-	nodes. Unlike DOT which provides read-only access, grab allows for targeted modifications of node attributes without
-	replacing the entire node.
-
-	Each method returns a function that takes a node, applies a transformation to a specific attribute of that node, and
-	returns the modified node. This enables fine-grained control when transforming AST structures.
-	"""
-	@staticmethod
-	def andDoAllOf(listOfActions: list[Callable[[NodeORattribute], NodeORattribute]]) -> Callable[[NodeORattribute], NodeORattribute]:
-		def workhorse(node: NodeORattribute) -> NodeORattribute:
-			for action in listOfActions:
-				node = action(node)
-			return node
-		return workhorse
-
-	@staticmethod
-	def argAttribute(action: Callable[[ast_Identifier | None], ast_Identifier]) -> Callable[[ast.arg | ast.keyword], ast.arg | ast.keyword]:
-		def workhorse(node: ast.arg | ast.keyword) -> ast.arg | ast.keyword:
-			node.arg = action(node.arg)
-			return node
-		return workhorse
-
-	@staticmethod
-	def attrAttribute(action: Callable[[ast_Identifier], ast_Identifier]) -> Callable[[ast.Attribute], ast.Attribute]:
-		def workhorse(node: ast.Attribute) -> ast.Attribute:
-			node.attr = action(node.attr)
-			return node
-		return workhorse
-
-	@staticmethod
-	def comparatorsAttribute(action: Callable[[list[ast.expr]], list[ast.expr]]) -> Callable[[ast.Compare], ast.Compare]:
-		def workhorse(node: ast.Compare) -> ast.Compare:
-			node.comparators = action(node.comparators)
-			return node
-		return workhorse
-
-	@staticmethod
-	def funcAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[ast.Call], ast.Call]:
-		def workhorse(node: ast.Call) -> ast.Call:
-			node.func = action(node.func)
-			return node
-		return workhorse
-
-	@staticmethod
-	def funcDOTidAttribute(action: Callable[[ast_Identifier], Any]) -> Callable[[ImaCallToName], ImaCallToName]:
-		def workhorse(node: ImaCallToName) -> ImaCallToName:
-			node.func = grab.idAttribute(action)(node.func)
-			return node
-		return workhorse
-
-	@staticmethod
-	def idAttribute(action: Callable[[ast_Identifier], ast_Identifier]) -> Callable[[ast.Name], ast.Name]:
-		def workhorse(node: ast.Name) -> ast.Name:
-			node.id = action(node.id)
-			return node
-		return workhorse
-
-	@staticmethod
-	def leftAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[ast.BinOp | ast.Compare], ast.BinOp | ast.Compare]:
-		def workhorse(node: ast.BinOp | ast.Compare) -> ast.BinOp | ast.Compare:
-			node.left = action(node.left)
-			return node
-		return workhorse
-
-	@staticmethod
-	def opsAttribute(action: Callable[[list[ast.cmpop]], list[ast.cmpop]]) -> Callable[[ast.Compare], ast.Compare]:
-		def workhorse(node: ast.Compare) -> ast.Compare:
-			node.ops = action(node.ops)
-			return node
-		return workhorse
-
-	@staticmethod
-	def testAttribute(action: Callable[[ast.expr], ast.expr]) -> Callable[[ast.Assert | ast.If | ast.IfExp | ast.While], ast.Assert | ast.If | ast.IfExp | ast.While]:
-		def workhorse(node: ast.Assert | ast.If | ast.IfExp | ast.While) -> ast.Assert | ast.If | ast.IfExp | ast.While:
-			node.test = action(node.test)
-			return node
-		return workhorse
-
-	@staticmethod
-	def valueAttribute(action: Callable[[Any], Any]) -> Callable[[astClassHasDOTvalue], astClassHasDOTvalue]:
-		def workhorse(node: astClassHasDOTvalue) -> astClassHasDOTvalue:
-			node.value = action(node.value)
-			return node
-		return workhorse
-
-class Then:
-	"""
-	Provide action functions that specify what to do with AST nodes that match predicates.
-
-	The Then class contains static methods that generate action functions used with NodeChanger and NodeTourist to
-	transform or extract information from AST nodes that match specific predicates. These actions include node
-	replacement, insertion, extraction, and collection operations.
-
-	When paired with predicates from the ifThis class, Then methods complete the pattern-matching-and-action workflow
-	for AST manipulation.
-	"""
-	@staticmethod
-	def appendTo(listOfAny: list[Any]) -> Callable[[ast.AST | ast_Identifier], ast.AST | ast_Identifier]:
-		def workhorse(node: ast.AST | ast_Identifier) -> ast.AST | ast_Identifier:
-			listOfAny.append(node)
-			return node
-		return workhorse
-
-	@staticmethod
-	def extractIt(node: NodeORattribute) -> NodeORattribute:
-		return node
-
-	@staticmethod
-	def insertThisAbove(list_astAST: Sequence[ast.AST]) -> Callable[[ast.AST], Sequence[ast.AST]]:
-		return lambda aboveMe: [*list_astAST, aboveMe]
-
-	@staticmethod
-	def insertThisBelow(list_astAST: Sequence[ast.AST]) -> Callable[[ast.AST], Sequence[ast.AST]]:
-		return lambda belowMe: [belowMe, *list_astAST]
-
-	@staticmethod
-	def removeIt(_removeMe: ast.AST) -> None:
-		return None
-
-	@staticmethod
-	def replaceWith(astAST: NodeORattribute) -> Callable[[NodeORattribute], NodeORattribute]:
-		return lambda _replaceMe: astAST
-
-	@staticmethod
-	def updateKeyValueIn(key: Callable[..., Any], value: Callable[..., Any], dictionary: dict[Any, Any]) -> Callable[[ast.AST], dict[Any, Any]]:
-		def workhorse(node: ast.AST) -> dict[Any, Any]:
-			dictionary.setdefault(key(node), value(node))
-			return dictionary
-		return workhorse

mapFolding/someAssemblyRequired/_toolboxAST.py

@@ -1,57 +0,0 @@
-from mapFolding.someAssemblyRequired import ast_Identifier, ifThis, IngredientsFunction, LedgerOfImports, NodeTourist, Then
-from mapFolding.theSSOT import raiseIfNoneGitHubIssueNumber3
-import ast
-
-def astModuleToIngredientsFunction(astModule: ast.AST, identifierFunctionDef: ast_Identifier) -> IngredientsFunction:
-	"""
-	Extract a function definition from an AST module and create an `IngredientsFunction`.
-
-	This function finds a function definition with the specified identifier in the given AST module, extracts it, and
-	stores all module imports in the `LedgerOfImports`.
-
-	Parameters:
-		astModule: The AST module containing the function definition.
-		identifierFunctionDef: The name of the function to extract.
-
-	Returns:
-		ingredientsFunction: `IngredientsFunction` object containing the `ast.FunctionDef` and _all_ imports from the
-		source module.
-
-	Raises:
-		raiseIfNoneGitHubIssueNumber3: If the function definition is not found.
-	"""
-	astFunctionDef = extractFunctionDef(astModule, identifierFunctionDef)
-	if not astFunctionDef: raise raiseIfNoneGitHubIssueNumber3
-	return IngredientsFunction(astFunctionDef, LedgerOfImports(astModule))
-
-def extractClassDef(module: ast.AST, identifier: ast_Identifier) -> ast.ClassDef | None:
-	"""
-	Extract a class definition with a specific name from an AST module.
-
-	This function searches through an AST module for a class definition that matches the provided identifier and returns
-	it if found.
-
-	Parameters:
-		module: The AST module to search within.
-		identifier: The name of the class to find.
-
-	Returns:
-		astClassDef|None: The matching class definition AST node, or `None` if not found.
-	"""
-	return NodeTourist(ifThis.isClassDef_Identifier(identifier), Then.extractIt).captureLastMatch(module)
-
-def extractFunctionDef(module: ast.AST, identifier: ast_Identifier) -> ast.FunctionDef | None:
-	"""
-	Extract a function definition with a specific name from an AST module.
-
-	This function searches through an AST module for a function definition that matches the provided identifier and
-	returns it if found.
-
-	Parameters:
-		module: The AST module to search within.
-		identifier: The name of the function to find.
-
-	Returns:
-		astFunctionDef|None: The matching function definition AST node, or `None` if not found.
-	"""
-	return NodeTourist(ifThis.isFunctionDef_Identifier(identifier), Then.extractIt).captureLastMatch(module)

mapFolding/someAssemblyRequired/_toolboxAntecedents.py

@@ -1,404 +0,0 @@
-"""
-AST Node Predicate and Access Utilities for Pattern Matching and Traversal
-
-This module provides utilities for accessing and matching AST nodes in a consistent way. It contains three primary
-classes:
-
-1. DOT: Provides consistent accessor methods for AST node attributes across different node types, simplifying the access
-	to node properties.
-
-2. be: Offers type-guard functions that verify AST node types, enabling safe type narrowing for static type checking and
-	improving code safety.
-
-3. ifThis: Contains predicate functions for matching AST nodes based on various criteria, enabling precise targeting of
-	nodes for analysis or transformation.
-
-These utilities form the foundation of the pattern-matching component in the AST manipulation framework, working in
-conjunction with the NodeChanger and NodeTourist classes to enable precise and targeted code transformations. Together,
-they implement a declarative approach to AST manipulation that separates node identification (ifThis), type verification
-(be), and data access (DOT).
-"""
-
-from collections.abc import Callable
-from mapFolding.someAssemblyRequired import (
-	ast_Identifier,
-	astClassHasDOTbody,
-	astClassHasDOTbody_expr,
-	astClassHasDOTbodyList_stmt,
-	astClassHasDOTnameNotName,
-	astClassHasDOTnameNotNameAlways,
-	astClassHasDOTnameNotNameOptionally,
-	astClassHasDOTtarget,
-	astClassHasDOTtarget_expr,
-	astClassHasDOTtargetAttributeNameSubscript,
-	astClassHasDOTvalue,
-	astClassHasDOTvalue_expr,
-	astClassHasDOTvalue_exprNone,
-	ImaCallToName,
-)
-from typing import Any, overload, TypeGuard
-import ast
-
-class DOT:
-	"""
-	Access attributes and sub-nodes of AST elements via consistent accessor methods.
-
-	The DOT class provides static methods to access specific attributes of different types of AST nodes in a consistent
-	way. This simplifies attribute access across various node types and improves code readability by abstracting the
-	underlying AST structure details.
-
-	DOT is designed for safe, read-only access to node properties, unlike the grab class which is designed for modifying
-	node attributes.
-	"""
-	@staticmethod
-	@overload
-	def annotation(node: ast.AnnAssign) -> ast.expr:...
-	@staticmethod
-	@overload
-	def annotation(node: ast.arg) -> ast.expr | None:...
-	@staticmethod
-	def annotation(node: ast.AnnAssign | ast.arg) -> ast.expr | None:
-		return node.annotation
-
-	@staticmethod
-	@overload
-	def arg(node: ast.arg) -> ast_Identifier:...
-	@staticmethod
-	@overload
-	def arg(node: ast.keyword) -> ast_Identifier | None:...
-	@staticmethod
-	def arg(node: ast.arg | ast.keyword) -> ast_Identifier | None:
-		return node.arg
-
-	@staticmethod
-	def attr(node: ast.Attribute) -> ast_Identifier:
-		return node.attr
-
-	@staticmethod
-	@overload
-	def body(node: astClassHasDOTbodyList_stmt) -> list[ast.stmt]:...
-	@staticmethod
-	@overload
-	def body(node: astClassHasDOTbody_expr) -> ast.expr:...
-	@staticmethod
-	def body(node: astClassHasDOTbody) -> ast.expr | list[ast.stmt]:
-		return node.body
-
-	@staticmethod
-	@overload
-	def func(node: ImaCallToName) -> ast.Name:...
-	@staticmethod
-	@overload
-	def func(node: ast.Call) -> ast.expr:...
-	@staticmethod
-	def func(node: ast.Call | ImaCallToName) -> ast.expr | ast.Name:
-		return node.func
-
-	@staticmethod
-	def id(node: ast.Name) -> ast_Identifier:
-		return node.id
-
-	@staticmethod
-	@overload
-	def name(node: astClassHasDOTnameNotNameAlways) -> ast_Identifier:...
-	@staticmethod
-	@overload
-	def name(node: astClassHasDOTnameNotNameOptionally) -> ast_Identifier | None:...
-	@staticmethod
-	def name(node: astClassHasDOTnameNotName) -> ast_Identifier | None:
-		return node.name
-
-	@staticmethod
-	@overload
-	def target(node: ast.NamedExpr) -> ast.Name:...
-	@staticmethod
-	@overload
-	def target(node: astClassHasDOTtarget_expr) -> ast.expr:...
-	@staticmethod
-	@overload
-	def target(node: astClassHasDOTtargetAttributeNameSubscript) -> ast.Attribute | ast.Name | ast.Subscript:...
-	@staticmethod
-	def target(node: astClassHasDOTtarget) -> ast.Attribute | ast.expr | ast.Name | ast.Subscript:
-		return node.target
-
-	@staticmethod
-	@overload
-	def value(node: ast.Constant) -> Any:...
-	@staticmethod
-	@overload
-	def value(node: ast.MatchSingleton) -> bool | None:...
-	@staticmethod
-	@overload
-	def value(node: astClassHasDOTvalue_expr) -> ast.expr:...
-	@staticmethod
-	@overload
-	def value(node: astClassHasDOTvalue_exprNone) -> ast.expr | None:...
-	@staticmethod
-	def value(node: astClassHasDOTvalue) -> Any | ast.expr | bool | None:
-		return node.value
-
-class be:
-	"""
-	Provide type-guard functions for safely verifying AST node types during manipulation.
-
-	The be class contains static methods that perform runtime type verification of AST nodes, returning TypeGuard
-	results that enable static type checkers to narrow node types in conditional branches. These type-guards:
-
-	1. Improve code safety by preventing operations on incompatible node types.
-	2. Enable IDE tooling to provide better autocompletion and error detection.
-	3. Document expected node types in a way that's enforced by the type system.
-	4. Support pattern-matching workflows where node types must be verified before access.
-
-	When used with conditional statements, these type-guards allow for precise, type-safe manipulation of AST nodes
-	while maintaining full static type checking capabilities, even in complex transformation scenarios.
-	"""
-	@staticmethod
-	def AnnAssign(node: ast.AST) -> TypeGuard[ast.AnnAssign]:
-		return isinstance(node, ast.AnnAssign)
-
-	@staticmethod
-	def arg(node: ast.AST) -> TypeGuard[ast.arg]:
-		return isinstance(node, ast.arg)
-
-	@staticmethod
-	def Assign(node: ast.AST) -> TypeGuard[ast.Assign]:
-		return isinstance(node, ast.Assign)
-
-	@staticmethod
-	def Attribute(node: ast.AST) -> TypeGuard[ast.Attribute]:
-		return isinstance(node, ast.Attribute)
-
-	@staticmethod
-	def AugAssign(node: ast.AST) -> TypeGuard[ast.AugAssign]:
-		return isinstance(node, ast.AugAssign)
-
-	@staticmethod
-	def Call(node: ast.AST) -> TypeGuard[ast.Call]:
-		return isinstance(node, ast.Call)
-
-	@staticmethod
-	def ClassDef(node: ast.AST) -> TypeGuard[ast.ClassDef]:
-		return isinstance(node, ast.ClassDef)
-
-	@staticmethod
-	def Compare(node: ast.AST) -> TypeGuard[ast.Compare]:
-		return isinstance(node, ast.Compare)
-
-	@staticmethod
-	def Constant(node: ast.AST) -> TypeGuard[ast.Constant]:
-		return isinstance(node, ast.Constant)
-
-	@staticmethod
-	def FunctionDef(node: ast.AST) -> TypeGuard[ast.FunctionDef]:
-		return isinstance(node, ast.FunctionDef)
-
-	@staticmethod
-	def keyword(node: ast.AST) -> TypeGuard[ast.keyword]:
-		return isinstance(node, ast.keyword)
-
-	@staticmethod
-	def If(node: ast.AST) -> TypeGuard[ast.If]:
-		return isinstance(node, ast.If)
-
-	@staticmethod
-	def Gt(node: ast.AST) -> TypeGuard[ast.Gt]:
-		return isinstance(node, ast.Gt)
-
-	@staticmethod
-	def LtE(node: ast.AST) -> TypeGuard[ast.LtE]:
-		return isinstance(node, ast.LtE)
-
-	@staticmethod
-	def Name(node: ast.AST) -> TypeGuard[ast.Name]:
-		return isinstance(node, ast.Name)
-
-	@staticmethod
-	def Not(node: ast.AST) -> TypeGuard[ast.Not]:
-		return isinstance(node, ast.Not)
-
-	@staticmethod
-	def Return(node: ast.AST) -> TypeGuard[ast.Return]:
-		return isinstance(node, ast.Return)
-
-	@staticmethod
-	def Starred(node: ast.AST) -> TypeGuard[ast.Starred]:
-		return isinstance(node, ast.Starred)
-
-	@staticmethod
-	def Subscript(node: ast.AST) -> TypeGuard[ast.Subscript]:
-		return isinstance(node, ast.Subscript)
-
-	@staticmethod
-	def Tuple(node: ast.AST) -> TypeGuard[ast.Tuple]:
-		return isinstance(node, ast.Tuple)
-
-	@staticmethod
-	def UnaryOp(node: ast.AST) -> TypeGuard[ast.UnaryOp]:
-		return isinstance(node, ast.UnaryOp)
-
-	@staticmethod
-	def While(node: ast.AST) -> TypeGuard[ast.While]:
-		return isinstance(node, ast.While)
-
-class ifThis:
-	"""
-	Provide predicate functions for matching and filtering AST nodes based on various criteria.
-
-	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,
-	enabling precise targeting of AST elements for analysis or transformation.
-	"""
-	@staticmethod
-	def _Identifier(identifier: ast_Identifier) -> Callable[[ast_Identifier | None], TypeGuard[ast_Identifier] | bool]:
-		return lambda node: node == identifier
-	@staticmethod
-	def _nested_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Attribute | ast.Starred | ast.Subscript] | bool]:
-		def workhorse(node: ast.AST) -> TypeGuard[ast.Attribute | ast.Starred | ast.Subscript] | bool:
-			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 is_arg_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.arg] | bool]:
-		"""see also `isArgument_Identifier`"""
-		return lambda node: be.arg(node) and ifThis._Identifier(identifier)(DOT.arg(node))
-	@staticmethod
-	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 ifThis._Identifier(identifier)(DOT.arg(node))
-
-	@staticmethod
-	def isAnnAssign_targetIs(targetPredicate: Callable[[ast.expr], TypeGuard[ast.expr] | bool]) -> Callable[[ast.AST], TypeGuard[ast.AnnAssign] | bool]:
-		def workhorse(node: ast.AST) -> TypeGuard[ast.AnnAssign] | bool:
-			return be.AnnAssign(node) and targetPredicate(DOT.target(node))
-		return workhorse
-
-	@staticmethod
-	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 ifThis._Identifier(identifier)(DOT.arg(node))
-
-	@staticmethod
-	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[ast.Assign] | bool]:
-		"""node is ast.Assign and node.value matches `valuePredicate`. """
-		return lambda node: be.Assign(node) and valuePredicate(DOT.value(node))
-
-	@staticmethod
-	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[ast.Attribute]:
-			return be.Attribute(node) and ifThis._nested_Identifier(identifier)(DOT.value(node))
-		return workhorse
-	@staticmethod
-	def isAttributeName(node: ast.AST) -> TypeGuard[ast.Attribute]:
-		""" Displayed as Name.attribute."""
-		return be.Attribute(node) and be.Name(DOT.value(node))
-	@staticmethod
-	def isAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Attribute] | bool]:
-		return lambda node: ifThis.isAttributeName(node) and ifThis.isName_Identifier(namespace)(DOT.value(node)) and ifThis._Identifier(identifier)(DOT.attr(node))
-
-	@staticmethod
-	def isAttributeNamespace_IdentifierGreaterThan0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
-		return lambda node: (be.Compare(node)
-					and ifThis.isAttributeNamespace_Identifier(namespace, identifier)(node.left)
-					and be.Gt(node.ops[0])
-					and ifThis.isConstant_value(0)(node.comparators[0]))
-
-	@staticmethod
-	def isUnaryNotAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.UnaryOp] | bool]:
-		return lambda node: (be.UnaryOp(node)
-					and be.Not(node.op)
-					and ifThis.isAttributeNamespace_Identifier(namespace, identifier)(node.operand))
-
-	@staticmethod
-	def isIfUnaryNotAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.If] | bool]:
-		return lambda node: (be.If(node)
-					and ifThis.isUnaryNotAttributeNamespace_Identifier(namespace, identifier)(node.test))
-
-	@staticmethod
-	def isIfAttributeNamespace_IdentifierGreaterThan0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.If] | bool]:
-		return lambda node: (be.If(node)
-					and ifThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(node.test))
-
-	@staticmethod
-	def isWhileAttributeNamespace_IdentifierGreaterThan0(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.While] | bool]:
-		return lambda node: (be.While(node)
-					and ifThis.isAttributeNamespace_IdentifierGreaterThan0(namespace, identifier)(node.test))
-
-	@staticmethod
-	def isAttributeNamespace_IdentifierLessThanOrEqual(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Compare] | bool]:
-		return lambda node: (be.Compare(node)
-					and ifThis.isAttributeNamespace_Identifier(namespace, identifier)(node.left)
-					and be.LtE(node.ops[0]))
-
-	@staticmethod
-	def isAugAssign_targetIs(targetPredicate: Callable[[ast.expr], TypeGuard[ast.expr] | bool]) -> Callable[[ast.AST], TypeGuard[ast.AugAssign] | bool]:
-		def workhorse(node: ast.AST) -> TypeGuard[ast.AugAssign] | bool:
-			return be.AugAssign(node) and targetPredicate(DOT.target(node))
-		return workhorse
-
-	@staticmethod
-	def isCall_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ImaCallToName] | bool]:
-		def workhorse(node: ast.AST) -> TypeGuard[ImaCallToName] | bool:
-			return ifThis.isCallToName(node) and ifThis._Identifier(identifier)(DOT.id(DOT.func(node)))
-		return workhorse
-
-	@staticmethod
-	def isCallAttributeNamespace_Identifier(namespace: ast_Identifier, identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Call] | bool]:
-		def workhorse(node: ast.AST) -> TypeGuard[ast.Call] | bool:
-			return be.Call(node) and ifThis.isAttributeNamespace_Identifier(namespace, identifier)(DOT.func(node))
-		return workhorse
-	@staticmethod
-	def isCallToName(node: ast.AST) -> TypeGuard[ImaCallToName]:
-		return be.Call(node) and be.Name(DOT.func(node))
-
-	@staticmethod
-	def isClassDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.ClassDef] | bool]:
-		return lambda node: be.ClassDef(node) and ifThis._Identifier(identifier)(DOT.name(node))
-
-	@staticmethod
-	def isConstant_value(value: Any) -> Callable[[ast.AST], TypeGuard[ast.Constant] | bool]:
-		return lambda node: be.Constant(node) and DOT.value(node) == value
-
-	@staticmethod
-	def isFunctionDef_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.FunctionDef] | bool]:
-		return lambda node: be.FunctionDef(node) and ifThis._Identifier(identifier)(DOT.name(node))
-
-	@staticmethod
-	def isName_Identifier(identifier: ast_Identifier) -> Callable[[ast.AST], TypeGuard[ast.Name] | bool]:
-		return lambda node: be.Name(node) and ifThis._Identifier(identifier)(DOT.id(node))
-
-	@staticmethod
-	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[ast.Starred]:
-			return be.Starred(node) and ifThis._nested_Identifier(identifier)(DOT.value(node))
-		return workhorse
-	@staticmethod
-	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[ast.Subscript]:
-			return be.Subscript(node) and ifThis._nested_Identifier(identifier)(DOT.value(node))
-		return workhorse
-
-	@staticmethod
-	def matchesMeButNotAnyDescendant(predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], bool]:
-		return lambda node: predicate(node) and ifThis.matchesNoDescendant(predicate)(node)
-	@staticmethod
-	def matchesNoDescendant(predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], bool]:
-		def workhorse(node: ast.AST) -> bool:
-			for descendant in ast.walk(node):
-				if descendant is not node and predicate(descendant):
-					return False
-			return True
-		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)
-		return workhorse