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

mapFolding/someAssemblyRequired/_tool_Make.py

@@ -0,0 +1,99 @@
+from collections.abc import Sequence
+from mapFolding.someAssemblyRequired import (
+	ast_expr_Slice,
+	ast_Identifier,
+	ImaAnnotationType,
+	intORlist_ast_type_paramORstr_orNone,
+	intORstr_orNone,
+	list_ast_type_paramORstr_orNone,
+)
+from typing import Any
+import ast
+
+class Make:
+	"""Almost all parameters described here are only accessible through a method's `**keywordArguments` parameter.
+
+	Parameters:
+		context (ast.Load()): Are you loading from, storing to, or deleting the identifier? The `context` (also, `ctx`) value is `ast.Load()`, `ast.Store()`, or `ast.Del()`.
+		col_offset (0): int Position information specifying the column where an AST node begins.
+		end_col_offset (None): int|None Position information specifying the column where an AST node ends.
+		end_lineno (None): int|None Position information specifying the line number where an AST node ends.
+		level (0): int Module import depth level that controls relative vs absolute imports. Default 0 indicates absolute import.
+		lineno: int Position information manually specifying the line number where an AST node begins.
+		kind (None): str|None Used for type annotations in limited cases.
+		type_comment (None): str|None "type_comment is an optional string with the type annotation as a comment." or `# type: ignore`.
+		type_params: list[ast.type_param] Type parameters for generic type definitions.
+
+	The `ast._Attributes`, lineno, col_offset, end_lineno, and end_col_offset, hold position information; however, they are, importantly, _not_ `ast._fields`.
+	"""
+	@staticmethod
+	def alias(name: ast_Identifier, asname: ast_Identifier | None = None) -> ast.alias:
+		return ast.alias(name, asname)
+	@staticmethod
+	def AnnAssign(target: ast.Attribute | ast.Name | ast.Subscript, annotation: ImaAnnotationType, value: ast.expr | None = None, **keywordArguments: int) -> ast.AnnAssign: # `simple: int`: uses a clever int-from-boolean to assign the correct value to the `simple` attribute. So, don't make it a method parameter.
+		return ast.AnnAssign(target, annotation, value, simple=int(isinstance(target, ast.Name)), **keywordArguments)
+	@staticmethod
+	def arg(identifier: ast_Identifier, annotation: ast.expr | None = None, **keywordArguments: intORstr_orNone) -> ast.arg:
+		return ast.arg(identifier, annotation, **keywordArguments)
+	@staticmethod
+	def argumentsSpecification(posonlyargs:list[ast.arg]=[], args:list[ast.arg]=[], vararg:ast.arg|None=None, kwonlyargs:list[ast.arg]=[], kw_defaults:list[ast.expr|None]=[None], kwarg:ast.arg|None=None, defaults:list[ast.expr]=[]) -> ast.arguments:
+		return ast.arguments(posonlyargs, args, vararg, kwonlyargs, kw_defaults, kwarg, defaults)
+	@staticmethod
+	def Assign(listTargets: Any, value: ast.expr, **keywordArguments: intORstr_orNone) -> ast.Assign:
+		return ast.Assign(listTargets, value, **keywordArguments)
+	@staticmethod
+	def Attribute(value: ast.expr, *attribute: ast_Identifier, context: ast.expr_context = ast.Load(), **keywordArguments: int) -> ast.Attribute:
+		""" If two `ast_Identifier` are joined by a dot `.`, they are _usually_ an `ast.Attribute`, but see `ast.ImportFrom`.
+		Parameters:
+			value: the part before the dot (Often `ast.Name`, but also `ast.Attribute`, `ast.Starred`, and `ast.Subscript`.)
+			attribute: an `ast_Identifier` after a dot `.`; you can pass multiple `attribute` and they will be chained together.
+		"""
+		# TODO confirm the precision of the docstring.
+		def addDOTattribute(chain, identifier: ast_Identifier, context: ast.expr_context, **keywordArguments: int) -> ast.Attribute:
+			return ast.Attribute(value=chain, attr=identifier, ctx=context, **keywordArguments)
+		buffaloBuffalo = addDOTattribute(value, attribute[0], context, **keywordArguments)
+		for identifier in attribute[1:None]:
+			buffaloBuffalo = addDOTattribute(buffaloBuffalo, identifier, context, **keywordArguments)
+		return buffaloBuffalo
+	@staticmethod
+	# TODO are the types for `callee` comprehensive?
+	# TODO is there an easier way to create precise typings for `ast`? I mean, it's a fucking closed system: there should be a lot of mystery involved.
+	def Call(callee: ast.Attribute | ast.Name | ast.Subscript, listArguments: Sequence[ast.expr] | None = None, list_astKeywords: Sequence[ast.keyword] | None = None) -> ast.Call:
+		return ast.Call(func=callee, args=list(listArguments) if listArguments else [], keywords=list(list_astKeywords) if list_astKeywords else [])
+	@staticmethod
+	def ClassDef(name: ast_Identifier, listBases: list[ast.expr]=[], list_keyword: list[ast.keyword]=[], body: list[ast.stmt]=[], decorator_list: list[ast.expr]=[], **keywordArguments: list_ast_type_paramORstr_orNone) -> ast.ClassDef:
+		return ast.ClassDef(name, listBases, list_keyword, body, decorator_list, **keywordArguments)
+	@staticmethod
+	def Constant(value: Any, **keywordArguments: intORstr_orNone) -> ast.Constant:
+		"""value: str|int|float|bool|None|bytes|bytearray|memoryview|complex|list|tuple|dict|set, or any other type that can be represented as a constant in Python."""
+		return ast.Constant(value, **keywordArguments)
+	@staticmethod
+	def Expr(value: ast.expr, **keywordArguments: int) -> ast.Expr:
+		return ast.Expr(value, **keywordArguments)
+	@staticmethod
+	def FunctionDef(name: ast_Identifier, argumentsSpecification:ast.arguments=ast.arguments(), body:list[ast.stmt]=[], decorator_list:list[ast.expr]=[], returns:ast.expr|None=None, **keywordArguments: intORlist_ast_type_paramORstr_orNone) -> ast.FunctionDef:
+		return ast.FunctionDef(name, argumentsSpecification, body, decorator_list, returns, **keywordArguments)
+	@staticmethod
+	def Import(moduleIdentifier: ast_Identifier, asname: ast_Identifier | None = None, **keywordArguments: int) -> ast.Import:
+		return ast.Import(names=[Make.alias(moduleIdentifier, asname)], **keywordArguments)
+	@staticmethod
+	def ImportFrom(moduleIdentifier: ast_Identifier, list_astAlias: list[ast.alias], **keywordArguments: int) -> ast.ImportFrom:
+		return ast.ImportFrom(moduleIdentifier, list_astAlias, **keywordArguments)
+	@staticmethod
+	def keyword(keywordArgument: ast_Identifier, value: ast.expr, **keywordArguments: int) -> ast.keyword:
+		return ast.keyword(arg=keywordArgument, value=value, **keywordArguments)
+	@staticmethod
+	def Module(body: list[ast.stmt] = [], type_ignores: list[ast.TypeIgnore] = []) -> ast.Module:
+		return ast.Module(body, type_ignores)
+	@staticmethod
+	def Name(identifier: ast_Identifier, context: ast.expr_context = ast.Load(), **keywordArguments: int) -> ast.Name:
+		return ast.Name(identifier, context, **keywordArguments)
+	@staticmethod
+	def Return(value: ast.expr | None = None, **keywordArguments: int) -> ast.Return:
+		return ast.Return(value, **keywordArguments)
+	@staticmethod
+	def Subscript(value: ast.expr, slice: ast_expr_Slice, context: ast.expr_context = ast.Load(), **keywordArguments: int) -> ast.Subscript:
+		return ast.Subscript(value, slice, context, **keywordArguments)
+	@staticmethod
+	def Tuple(elements: Sequence[ast.expr] = [], context: ast.expr_context = ast.Load(), **keywordArguments: int) -> ast.Tuple:
+		return ast.Tuple(list(elements), context, **keywordArguments)

mapFolding/someAssemblyRequired/_tool_Then.py

@@ -0,0 +1,72 @@
+from collections.abc import Callable, Sequence
+from mapFolding.someAssemblyRequired import ast_Identifier, astClassHasDOTvalue
+from typing import Any
+import ast
+
+class Then:
+	@staticmethod
+	def allOf(listActions: Sequence[Callable[[ast.AST], Any]]) -> Callable[[ast.AST], ast.AST]:
+		def workhorse(node: ast.AST) -> ast.AST:
+			for action in listActions: action(node)
+			return node
+		return workhorse
+
+	@staticmethod
+	def appendTo(listOfAny: list[Any]) -> Callable[[ast.AST | ast_Identifier], list[Any]]:
+		def workhorse(node: ast.AST | ast_Identifier) -> list[Any]:
+			listOfAny.append(node)
+			return listOfAny
+		return workhorse
+
+	@staticmethod
+	def DOTarg(action: Callable[[Any], Any]) -> 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 DOTfunc(action: Callable[[Any], Any]) -> Callable[[ast.Call], ast.Call]:
+		def workhorse(node: ast.Call) -> ast.Call:
+			node.func = action(node.func)
+			return node
+		return workhorse
+	@staticmethod
+	def DOTid(action: Callable[[Any], Any]) -> Callable[[ast.Name], ast.Name]:
+		def workhorse(node: ast.Name) -> ast.Name:
+			node.id = action(node.id)
+			return node
+		return workhorse
+	@staticmethod
+	def DOTtarget(action: Callable[[Any], Any]) -> Callable[[ast.AnnAssign | ast.AugAssign], ast.AnnAssign | ast.AugAssign]:
+		def workhorse(node: ast.AnnAssign | ast.AugAssign) -> ast.AnnAssign | ast.AugAssign:
+			node.target = action(node.target)
+			return node
+		return workhorse
+	@staticmethod
+	def DOTvalue(action: Callable[[Any], Any]) -> Callable[[astClassHasDOTvalue], astClassHasDOTvalue]:
+		def workhorse(node: astClassHasDOTvalue) -> astClassHasDOTvalue:
+			node.value = action(node.value)
+			return node
+		return workhorse
+
+	@staticmethod
+	def getIt(node: ast.AST) -> ast.AST | ast_Identifier:
+		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(_node: ast.AST) -> None: return None
+	@staticmethod
+	def replaceWith(astAST: ast.AST | ast_Identifier) -> Callable[[ast.AST], ast.AST | ast_Identifier]:
+		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/_toolboxAntecedents.py

@@ -0,0 +1,358 @@
+from collections.abc import Callable, Container
+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
+
+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
+	@overload
+	def annotation(predicate: Callable[[ImaAnnotationType], ast.AST | ast_Identifier]) -> Callable[[ast.AnnAssign | ast.arg], ast.AST | ast_Identifier]:...
+	@staticmethod
+	@overload
+	def annotation(predicate: Callable[[ImaAnnotationType], TypeGuard[ImaAnnotationType] | bool]) -> Callable[[ast.AnnAssign | ast.arg], TypeGuard[ast.AnnAssign] | TypeGuard[ast.arg] | bool]:...
+	@staticmethod
+	def annotation(predicate: Callable[[ImaAnnotationType], TypeGuard[ImaAnnotationType] | ast.AST | ast_Identifier | bool]) -> Callable[[ast.AnnAssign | ast.arg], TypeGuard[ast.AnnAssign] | TypeGuard[ast.arg] | ast.AST | ast_Identifier | bool]:
+		@overload
+		def workhorse(node: ast.AnnAssign | ast.arg) -> ast.AST | ast_Identifier:...
+		@overload
+		def workhorse(node: ast.AnnAssign | ast.arg) -> TypeGuard[ast.AnnAssign] | TypeGuard[ast.arg] | bool:...
+		def workhorse(node: ast.AnnAssign | ast.arg) -> TypeGuard[ast.AnnAssign] | TypeGuard[ast.arg] | ast.AST | ast_Identifier | bool:
+			ImaAnnotation = node.annotation
+			if ImaAnnotation is None: return False
+			assert be.Attribute(ImaAnnotation) or be.Constant(ImaAnnotation) or be.Name(ImaAnnotation) or be.Subscript(ImaAnnotation)
+			# assert be.Annotation(ImaAnnotation)
+			return predicate(ImaAnnotation)
+		return workhorse
+	@staticmethod
+	@overload
+	def arg(predicate: Callable[[ast_Identifier], ast.AST | ast_Identifier]) -> Callable[[ast.arg | ast.keyword], ast.AST | ast_Identifier]:...
+	@staticmethod
+	@overload
+	def arg(predicate: Callable[[ast_Identifier], TypeGuard[ast_Identifier] | bool]) -> Callable[[ast.arg | ast.keyword], TypeGuard[ast.arg] | TypeGuard[ast.keyword] | bool]:...
+	@staticmethod
+	def arg(predicate: Callable[[ast_Identifier], TypeGuard[ast_Identifier] | ast.AST | ast_Identifier | bool]) -> Callable[[ast.arg | ast.keyword], TypeGuard[ast.arg] | TypeGuard[ast.keyword] | ast.AST | ast_Identifier | bool]:
+		@overload
+		def workhorse(node: ast.arg | ast.keyword) -> ast.AST | ast_Identifier:...
+		@overload
+		def workhorse(node: ast.arg | ast.keyword) -> TypeGuard[ast.arg] | TypeGuard[ast.keyword] | bool:...
+		def workhorse(node: ast.arg | ast.keyword) -> TypeGuard[ast.arg] | TypeGuard[ast.keyword] | ast.AST | ast_Identifier | bool:
+			Ima_arg = node.arg
+			if Ima_arg is None: return False
+			return predicate(Ima_arg)
+		return workhorse
+	@staticmethod
+	def asname(predicate: Callable[[ast_Identifier | None], TypeGuard[ast_Identifier] | bool]) -> Callable[[ast.alias], TypeGuard[ast.alias] | bool]:
+		return lambda node: predicate(node.asname)
+	@staticmethod
+	def attr(predicate: Callable[[ast_Identifier], TypeGuard[ast_Identifier] | bool]) -> Callable[[ast.Attribute], TypeGuard[ast.Attribute] | bool]:
+		return lambda node: predicate(node.attr)
+	@staticmethod
+	def func(predicate: Callable[[ast.AST], TypeGuard[ast.AST] | bool]) -> Callable[[ast.Call], TypeGuard[ast.Call] | bool]:
+		return lambda node: predicate(node.func)
+	@staticmethod
+	def id(predicate: Callable[[ast_Identifier], TypeGuard[ast_Identifier] | bool]) -> Callable[[ast.Name], TypeGuard[ast.Name] | bool]:
+		return lambda node: predicate(node.id)
+	@staticmethod
+	def module(predicate: Callable[[ast_Identifier | None], TypeGuard[ast_Identifier] | bool]) -> Callable[[ast.ImportFrom], TypeGuard[ast.ImportFrom] | bool]:
+		return lambda node: predicate(node.module)
+	@staticmethod
+	def name(predicate: Callable[[ast_Identifier], TypeGuard[ast_Identifier] | bool]) -> Callable[[astClassHasDOTnameNotName], TypeGuard[astClassHasDOTnameNotName] | bool]:
+		return lambda node: predicate(node.name)
+	@staticmethod
+	def slice(predicate: Callable[[ast_expr_Slice], TypeGuard[ast_expr_Slice] | bool]) -> Callable[[ast.Subscript], TypeGuard[ast.Subscript] | bool]:
+		return lambda node: predicate(node.slice)
+	@staticmethod
+	def target(predicate: Callable[[ast.AST], TypeGuard[ast.AST] | bool]) -> Callable[[astClassHasDOTtarget], TypeGuard[astClassHasDOTtarget] | bool]:
+		return lambda node: predicate(node.target)
+	@staticmethod
+	def value(predicate: Callable[[ast.AST], TypeGuard[ast.AST] | bool]) -> Callable[[astClassHasDOTvalue], TypeGuard[astClassHasDOTvalue] | bool]:
+		def workhorse(node: astClassHasDOTvalue) -> TypeGuard[astClassHasDOTvalue] | bool:
+			ImaValue = node.value
+			if ImaValue is None: return False
+			return predicate(ImaValue)
+		return workhorse
+
+class be:
+	@staticmethod
+	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: 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: TypeCertified) -> TypeGuard[ast.arg]: return be._typeCertified(ast.arg)(node) # pyright: ignore [reportInvalidTypeVarUse]
+	@staticmethod
+	def Assign(node: TypeCertified) -> TypeGuard[ast.Assign]: return be._typeCertified(ast.Assign)(node) # pyright: ignore [reportInvalidTypeVarUse]
+	@staticmethod
+	def Attribute(node: TypeCertified) -> TypeGuard[ast.Attribute]: return be._typeCertified(ast.Attribute)(node) # pyright: ignore [reportInvalidTypeVarUse]
+	@staticmethod
+	def AugAssign(node: TypeCertified) -> TypeGuard[ast.AugAssign]: return be._typeCertified(ast.AugAssign)(node) # pyright: ignore [reportInvalidTypeVarUse]
+	@staticmethod
+	def BoolOp(node: TypeCertified) -> TypeGuard[ast.BoolOp]: return be._typeCertified(ast.BoolOp)(node) # pyright: ignore [reportInvalidTypeVarUse]
+	@staticmethod
+	def Call(node: TypeCertified) -> TypeGuard[ast.Call]: return be._typeCertified(ast.Call)(node) # pyright: ignore [reportInvalidTypeVarUse]
+	@staticmethod
+	def ClassDef(node: TypeCertified) -> TypeGuard[ast.ClassDef]: return be._typeCertified(ast.ClassDef)(node) # pyright: ignore [reportInvalidTypeVarUse]
+	@staticmethod
+	def Compare(node: TypeCertified) -> TypeGuard[ast.Compare]: return be._typeCertified(ast.Compare)(node) # pyright: ignore [reportInvalidTypeVarUse]
+	@staticmethod
+	def Constant(node: TypeCertified) -> TypeGuard[ast.Constant]: return be._typeCertified(ast.Constant)(node) # pyright: ignore [reportInvalidTypeVarUse]
+	@staticmethod
+	def Expr(node: TypeCertified) -> TypeGuard[ast.Expr]: return be._typeCertified(ast.Expr)(node) # pyright: ignore [reportInvalidTypeVarUse]
+	@staticmethod
+	def FunctionDef(node: TypeCertified) -> TypeGuard[ast.FunctionDef]: return be._typeCertified(ast.FunctionDef)(node) # pyright: ignore [reportInvalidTypeVarUse]
+	@staticmethod
+	def Import(node: TypeCertified) -> TypeGuard[ast.Import]: return be._typeCertified(ast.Import)(node) # pyright: ignore [reportInvalidTypeVarUse]
+	@staticmethod
+	def ImportFrom(node: TypeCertified) -> TypeGuard[ast.ImportFrom]: return be._typeCertified(ast.ImportFrom)(node) # pyright: ignore [reportInvalidTypeVarUse]
+	@staticmethod
+	def keyword(node: TypeCertified) -> TypeGuard[ast.keyword]: return be._typeCertified(ast.keyword)(node) # pyright: ignore [reportInvalidTypeVarUse]
+	@staticmethod
+	def Module(node: TypeCertified) -> TypeGuard[ast.Module]: return be._typeCertified(ast.Module)(node) # pyright: ignore [reportInvalidTypeVarUse]
+	@staticmethod
+	def Name(node: TypeCertified) -> TypeGuard[ast.Name]: return be._typeCertified(ast.Name)(node) # pyright: ignore [reportInvalidTypeVarUse]
+	@staticmethod
+	def Return(node: TypeCertified) -> TypeGuard[ast.Return]: return be._typeCertified(ast.Return)(node) # pyright: ignore [reportInvalidTypeVarUse]
+	@staticmethod
+	def Starred(node: TypeCertified) -> TypeGuard[ast.Starred]: return be._typeCertified(ast.Starred)(node) # pyright: ignore [reportInvalidTypeVarUse]
+	@staticmethod
+	def Subscript(node: TypeCertified) -> TypeGuard[ast.Subscript]: return be._typeCertified(ast.Subscript)(node) # pyright: ignore [reportInvalidTypeVarUse]
+	@staticmethod
+	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[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`.
+		Parameters:
+			valuePredicate: Function that evaluates the value of the assignment
+		Returns:
+			predicate: matches assignments with values meeting the criteria
+		"""
+		return lambda node: be.Assign(node) and 又.value(valuePredicate)(node)
+	@staticmethod
+	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[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[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[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[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[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[ast.Assign] | bool]:
+		return ifThis.isAssignAndValueIs(ifThis.isCallAttributeNamespace_Identifier(namespace, identifier))
+	@staticmethod
+	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[ast.keyword] | bool]:
+		return lambda node: ifThis.is_keyword_Identifier(identifier)(node) and ifThis.is_keywordAndValueIsConstant(node) and 又.value(ifThis.isConstantEquals(ConstantValue))(node)
+	@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: 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_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: 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[ast.Constant] | bool]:
+		return lambda node: be.Constant(node) and 又.value(ifThis.equals(value))(node)
+	@staticmethod
+	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: 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[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[ast.Attribute] | bool]:
+		"""node is `ast.Attribute` and the top-level `ast.Name` is `identifier`"""
+		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[ast.Starred] | bool]:
+		"""node is `ast.Starred` and the top-level `ast.Name` is `identifier`"""
+		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[ast.Subscript] | bool]:
+		"""node is `ast.Subscript` and the top-level `ast.Name` is `identifier`"""
+		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: TypeCertified) -> bool: return ast.unparse(node) == ast.unparse(astAST) # pyright: ignore [reportInvalidTypeVarUse]
+		return workhorse
+
+	# ================================================================
+	# NOT used
+	# TODO Does this work?
+	@staticmethod
+	def Z0Z_matchesAtLeast1Descendant(predicate: Callable[[ast.AST], bool]) -> Callable[[ast.AST], bool]:
+		"""Create a predicate that returns True if any descendant of the node matches the given predicate."""
+		return lambda node: not ifThis.matchesNoDescendant(predicate)(node)
+	# ================================================================
+	# MORE function inlining
+	@staticmethod
+	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[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[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[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[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: TypeCertified) -> bool: # pyright: ignore [reportInvalidTypeVarUse]
+			for descendant in ast.walk(node):
+				if descendant is not node and predicate(descendant):
+					return False
+			return True
+		return workhorse
+
+	@staticmethod
+	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[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: TypeCertified) -> TypeGuard[ast.Attribute]: # pyright: ignore [reportInvalidTypeVarUse]
+		""" Displayed as Name.attribute."""
+		return be.Attribute(node) and 又.value(be.Name)(node)
+
+	@staticmethod
+	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[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