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

mapFolding/someAssemblyRequired/_toolBe.py

@@ -0,0 +1,524 @@
+"""This file is generated automatically, so changes to this file will be lost."""
+from mapFolding import astDOTParamSpec, astDOTTryStar, astDOTTypeAlias, astDOTTypeVar, astDOTTypeVarTuple, astDOTtype_param
+from typing import TypeGuard
+import ast
+
+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 is 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 Add(node: ast.AST) -> TypeGuard[ast.Add]:
+        return isinstance(node, ast.Add)
+
+    @staticmethod
+    def alias(node: ast.AST) -> TypeGuard[ast.alias]:
+        return isinstance(node, ast.alias)
+
+    @staticmethod
+    def And(node: ast.AST) -> TypeGuard[ast.And]:
+        return isinstance(node, ast.And)
+
+    @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 arguments(node: ast.AST) -> TypeGuard[ast.arguments]:
+        return isinstance(node, ast.arguments)
+
+    @staticmethod
+    def Assert(node: ast.AST) -> TypeGuard[ast.Assert]:
+        return isinstance(node, ast.Assert)
+
+    @staticmethod
+    def Assign(node: ast.AST) -> TypeGuard[ast.Assign]:
+        return isinstance(node, ast.Assign)
+
+    @staticmethod
+    def AST(node: ast.AST) -> TypeGuard[ast.AST]:
+        return isinstance(node, ast.AST)
+
+    @staticmethod
+    def AsyncFor(node: ast.AST) -> TypeGuard[ast.AsyncFor]:
+        return isinstance(node, ast.AsyncFor)
+
+    @staticmethod
+    def AsyncFunctionDef(node: ast.AST) -> TypeGuard[ast.AsyncFunctionDef]:
+        return isinstance(node, ast.AsyncFunctionDef)
+
+    @staticmethod
+    def AsyncWith(node: ast.AST) -> TypeGuard[ast.AsyncWith]:
+        return isinstance(node, ast.AsyncWith)
+
+    @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 Await(node: ast.AST) -> TypeGuard[ast.Await]:
+        return isinstance(node, ast.Await)
+
+    @staticmethod
+    def BinOp(node: ast.AST) -> TypeGuard[ast.BinOp]:
+        return isinstance(node, ast.BinOp)
+
+    @staticmethod
+    def BitAnd(node: ast.AST) -> TypeGuard[ast.BitAnd]:
+        return isinstance(node, ast.BitAnd)
+
+    @staticmethod
+    def BitOr(node: ast.AST) -> TypeGuard[ast.BitOr]:
+        return isinstance(node, ast.BitOr)
+
+    @staticmethod
+    def BitXor(node: ast.AST) -> TypeGuard[ast.BitXor]:
+        return isinstance(node, ast.BitXor)
+
+    @staticmethod
+    def BoolOp(node: ast.AST) -> TypeGuard[ast.BoolOp]:
+        return isinstance(node, ast.BoolOp)
+
+    @staticmethod
+    def boolop(node: ast.AST) -> TypeGuard[ast.boolop]:
+        return isinstance(node, ast.boolop)
+
+    @staticmethod
+    def Break(node: ast.AST) -> TypeGuard[ast.Break]:
+        return isinstance(node, ast.Break)
+
+    @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 cmpop(node: ast.AST) -> TypeGuard[ast.cmpop]:
+        return isinstance(node, ast.cmpop)
+
+    @staticmethod
+    def Compare(node: ast.AST) -> TypeGuard[ast.Compare]:
+        return isinstance(node, ast.Compare)
+
+    @staticmethod
+    def comprehension(node: ast.AST) -> TypeGuard[ast.comprehension]:
+        return isinstance(node, ast.comprehension)
+
+    @staticmethod
+    def Constant(node: ast.AST) -> TypeGuard[ast.Constant]:
+        return isinstance(node, ast.Constant)
+
+    @staticmethod
+    def Continue(node: ast.AST) -> TypeGuard[ast.Continue]:
+        return isinstance(node, ast.Continue)
+
+    @staticmethod
+    def Del(node: ast.AST) -> TypeGuard[ast.Del]:
+        return isinstance(node, ast.Del)
+
+    @staticmethod
+    def Delete(node: ast.AST) -> TypeGuard[ast.Delete]:
+        return isinstance(node, ast.Delete)
+
+    @staticmethod
+    def Dict(node: ast.AST) -> TypeGuard[ast.Dict]:
+        return isinstance(node, ast.Dict)
+
+    @staticmethod
+    def DictComp(node: ast.AST) -> TypeGuard[ast.DictComp]:
+        return isinstance(node, ast.DictComp)
+
+    @staticmethod
+    def Div(node: ast.AST) -> TypeGuard[ast.Div]:
+        return isinstance(node, ast.Div)
+
+    @staticmethod
+    def Eq(node: ast.AST) -> TypeGuard[ast.Eq]:
+        return isinstance(node, ast.Eq)
+
+    @staticmethod
+    def excepthandler(node: ast.AST) -> TypeGuard[ast.excepthandler]:
+        return isinstance(node, ast.excepthandler)
+
+    @staticmethod
+    def ExceptHandler(node: ast.AST) -> TypeGuard[ast.ExceptHandler]:
+        return isinstance(node, ast.ExceptHandler)
+
+    @staticmethod
+    def Expr(node: ast.AST) -> TypeGuard[ast.Expr]:
+        return isinstance(node, ast.Expr)
+
+    @staticmethod
+    def expr(node: ast.AST) -> TypeGuard[ast.expr]:
+        return isinstance(node, ast.expr)
+
+    @staticmethod
+    def expr_context(node: ast.AST) -> TypeGuard[ast.expr_context]:
+        return isinstance(node, ast.expr_context)
+
+    @staticmethod
+    def Expression(node: ast.AST) -> TypeGuard[ast.Expression]:
+        return isinstance(node, ast.Expression)
+
+    @staticmethod
+    def FloorDiv(node: ast.AST) -> TypeGuard[ast.FloorDiv]:
+        return isinstance(node, ast.FloorDiv)
+
+    @staticmethod
+    def For(node: ast.AST) -> TypeGuard[ast.For]:
+        return isinstance(node, ast.For)
+
+    @staticmethod
+    def FormattedValue(node: ast.AST) -> TypeGuard[ast.FormattedValue]:
+        return isinstance(node, ast.FormattedValue)
+
+    @staticmethod
+    def FunctionDef(node: ast.AST) -> TypeGuard[ast.FunctionDef]:
+        return isinstance(node, ast.FunctionDef)
+
+    @staticmethod
+    def FunctionType(node: ast.AST) -> TypeGuard[ast.FunctionType]:
+        return isinstance(node, ast.FunctionType)
+
+    @staticmethod
+    def GeneratorExp(node: ast.AST) -> TypeGuard[ast.GeneratorExp]:
+        return isinstance(node, ast.GeneratorExp)
+
+    @staticmethod
+    def Global(node: ast.AST) -> TypeGuard[ast.Global]:
+        return isinstance(node, ast.Global)
+
+    @staticmethod
+    def Gt(node: ast.AST) -> TypeGuard[ast.Gt]:
+        return isinstance(node, ast.Gt)
+
+    @staticmethod
+    def GtE(node: ast.AST) -> TypeGuard[ast.GtE]:
+        return isinstance(node, ast.GtE)
+
+    @staticmethod
+    def If(node: ast.AST) -> TypeGuard[ast.If]:
+        return isinstance(node, ast.If)
+
+    @staticmethod
+    def IfExp(node: ast.AST) -> TypeGuard[ast.IfExp]:
+        return isinstance(node, ast.IfExp)
+
+    @staticmethod
+    def Import(node: ast.AST) -> TypeGuard[ast.Import]:
+        return isinstance(node, ast.Import)
+
+    @staticmethod
+    def ImportFrom(node: ast.AST) -> TypeGuard[ast.ImportFrom]:
+        return isinstance(node, ast.ImportFrom)
+
+    @staticmethod
+    def In(node: ast.AST) -> TypeGuard[ast.In]:
+        return isinstance(node, ast.In)
+
+    @staticmethod
+    def Interactive(node: ast.AST) -> TypeGuard[ast.Interactive]:
+        return isinstance(node, ast.Interactive)
+
+    @staticmethod
+    def Invert(node: ast.AST) -> TypeGuard[ast.Invert]:
+        return isinstance(node, ast.Invert)
+
+    @staticmethod
+    def Is(node: ast.AST) -> TypeGuard[ast.Is]:
+        return isinstance(node, ast.Is)
+
+    @staticmethod
+    def IsNot(node: ast.AST) -> TypeGuard[ast.IsNot]:
+        return isinstance(node, ast.IsNot)
+
+    @staticmethod
+    def JoinedStr(node: ast.AST) -> TypeGuard[ast.JoinedStr]:
+        return isinstance(node, ast.JoinedStr)
+
+    @staticmethod
+    def keyword(node: ast.AST) -> TypeGuard[ast.keyword]:
+        return isinstance(node, ast.keyword)
+
+    @staticmethod
+    def Lambda(node: ast.AST) -> TypeGuard[ast.Lambda]:
+        return isinstance(node, ast.Lambda)
+
+    @staticmethod
+    def List(node: ast.AST) -> TypeGuard[ast.List]:
+        return isinstance(node, ast.List)
+
+    @staticmethod
+    def ListComp(node: ast.AST) -> TypeGuard[ast.ListComp]:
+        return isinstance(node, ast.ListComp)
+
+    @staticmethod
+    def Load(node: ast.AST) -> TypeGuard[ast.Load]:
+        return isinstance(node, ast.Load)
+
+    @staticmethod
+    def LShift(node: ast.AST) -> TypeGuard[ast.LShift]:
+        return isinstance(node, ast.LShift)
+
+    @staticmethod
+    def Lt(node: ast.AST) -> TypeGuard[ast.Lt]:
+        return isinstance(node, ast.Lt)
+
+    @staticmethod
+    def LtE(node: ast.AST) -> TypeGuard[ast.LtE]:
+        return isinstance(node, ast.LtE)
+
+    @staticmethod
+    def Match(node: ast.AST) -> TypeGuard[ast.Match]:
+        return isinstance(node, ast.Match)
+
+    @staticmethod
+    def match_case(node: ast.AST) -> TypeGuard[ast.match_case]:
+        return isinstance(node, ast.match_case)
+
+    @staticmethod
+    def MatchAs(node: ast.AST) -> TypeGuard[ast.MatchAs]:
+        return isinstance(node, ast.MatchAs)
+
+    @staticmethod
+    def MatchClass(node: ast.AST) -> TypeGuard[ast.MatchClass]:
+        return isinstance(node, ast.MatchClass)
+
+    @staticmethod
+    def MatchMapping(node: ast.AST) -> TypeGuard[ast.MatchMapping]:
+        return isinstance(node, ast.MatchMapping)
+
+    @staticmethod
+    def MatchOr(node: ast.AST) -> TypeGuard[ast.MatchOr]:
+        return isinstance(node, ast.MatchOr)
+
+    @staticmethod
+    def MatchSequence(node: ast.AST) -> TypeGuard[ast.MatchSequence]:
+        return isinstance(node, ast.MatchSequence)
+
+    @staticmethod
+    def MatchSingleton(node: ast.AST) -> TypeGuard[ast.MatchSingleton]:
+        return isinstance(node, ast.MatchSingleton)
+
+    @staticmethod
+    def MatchStar(node: ast.AST) -> TypeGuard[ast.MatchStar]:
+        return isinstance(node, ast.MatchStar)
+
+    @staticmethod
+    def MatchValue(node: ast.AST) -> TypeGuard[ast.MatchValue]:
+        return isinstance(node, ast.MatchValue)
+
+    @staticmethod
+    def MatMult(node: ast.AST) -> TypeGuard[ast.MatMult]:
+        return isinstance(node, ast.MatMult)
+
+    @staticmethod
+    def mod(node: ast.AST) -> TypeGuard[ast.mod]:
+        return isinstance(node, ast.mod)
+
+    @staticmethod
+    def Mod(node: ast.AST) -> TypeGuard[ast.Mod]:
+        return isinstance(node, ast.Mod)
+
+    @staticmethod
+    def Module(node: ast.AST) -> TypeGuard[ast.Module]:
+        return isinstance(node, ast.Module)
+
+    @staticmethod
+    def Mult(node: ast.AST) -> TypeGuard[ast.Mult]:
+        return isinstance(node, ast.Mult)
+
+    @staticmethod
+    def Name(node: ast.AST) -> TypeGuard[ast.Name]:
+        return isinstance(node, ast.Name)
+
+    @staticmethod
+    def NamedExpr(node: ast.AST) -> TypeGuard[ast.NamedExpr]:
+        return isinstance(node, ast.NamedExpr)
+
+    @staticmethod
+    def NodeTransformer(node: ast.AST) -> TypeGuard[ast.NodeTransformer]:
+        return isinstance(node, ast.NodeTransformer)
+
+    @staticmethod
+    def NodeVisitor(node: ast.AST) -> TypeGuard[ast.NodeVisitor]:
+        return isinstance(node, ast.NodeVisitor)
+
+    @staticmethod
+    def Nonlocal(node: ast.AST) -> TypeGuard[ast.Nonlocal]:
+        return isinstance(node, ast.Nonlocal)
+
+    @staticmethod
+    def Not(node: ast.AST) -> TypeGuard[ast.Not]:
+        return isinstance(node, ast.Not)
+
+    @staticmethod
+    def NotEq(node: ast.AST) -> TypeGuard[ast.NotEq]:
+        return isinstance(node, ast.NotEq)
+
+    @staticmethod
+    def NotIn(node: ast.AST) -> TypeGuard[ast.NotIn]:
+        return isinstance(node, ast.NotIn)
+
+    @staticmethod
+    def operator(node: ast.AST) -> TypeGuard[ast.operator]:
+        return isinstance(node, ast.operator)
+
+    @staticmethod
+    def Or(node: ast.AST) -> TypeGuard[ast.Or]:
+        return isinstance(node, ast.Or)
+
+    @staticmethod
+    def ParamSpec(node: ast.AST) -> TypeGuard[astDOTParamSpec]:
+        return isinstance(node, astDOTParamSpec)
+
+    @staticmethod
+    def Pass(node: ast.AST) -> TypeGuard[ast.Pass]:
+        return isinstance(node, ast.Pass)
+
+    @staticmethod
+    def pattern(node: ast.AST) -> TypeGuard[ast.pattern]:
+        return isinstance(node, ast.pattern)
+
+    @staticmethod
+    def Pow(node: ast.AST) -> TypeGuard[ast.Pow]:
+        return isinstance(node, ast.Pow)
+
+    @staticmethod
+    def Raise(node: ast.AST) -> TypeGuard[ast.Raise]:
+        return isinstance(node, ast.Raise)
+
+    @staticmethod
+    def Return(node: ast.AST) -> TypeGuard[ast.Return]:
+        return isinstance(node, ast.Return)
+
+    @staticmethod
+    def RShift(node: ast.AST) -> TypeGuard[ast.RShift]:
+        return isinstance(node, ast.RShift)
+
+    @staticmethod
+    def Set(node: ast.AST) -> TypeGuard[ast.Set]:
+        return isinstance(node, ast.Set)
+
+    @staticmethod
+    def SetComp(node: ast.AST) -> TypeGuard[ast.SetComp]:
+        return isinstance(node, ast.SetComp)
+
+    @staticmethod
+    def Slice(node: ast.AST) -> TypeGuard[ast.Slice]:
+        return isinstance(node, ast.Slice)
+
+    @staticmethod
+    def Starred(node: ast.AST) -> TypeGuard[ast.Starred]:
+        return isinstance(node, ast.Starred)
+
+    @staticmethod
+    def stmt(node: ast.AST) -> TypeGuard[ast.stmt]:
+        return isinstance(node, ast.stmt)
+
+    @staticmethod
+    def Store(node: ast.AST) -> TypeGuard[ast.Store]:
+        return isinstance(node, ast.Store)
+
+    @staticmethod
+    def Sub(node: ast.AST) -> TypeGuard[ast.Sub]:
+        return isinstance(node, ast.Sub)
+
+    @staticmethod
+    def Subscript(node: ast.AST) -> TypeGuard[ast.Subscript]:
+        return isinstance(node, ast.Subscript)
+
+    @staticmethod
+    def Try(node: ast.AST) -> TypeGuard[ast.Try]:
+        return isinstance(node, ast.Try)
+
+    @staticmethod
+    def TryStar(node: ast.AST) -> TypeGuard[astDOTTryStar]:
+        return isinstance(node, astDOTTryStar)
+
+    @staticmethod
+    def Tuple(node: ast.AST) -> TypeGuard[ast.Tuple]:
+        return isinstance(node, ast.Tuple)
+
+    @staticmethod
+    def type_ignore(node: ast.AST) -> TypeGuard[ast.type_ignore]:
+        return isinstance(node, ast.type_ignore)
+
+    @staticmethod
+    def type_param(node: ast.AST) -> TypeGuard[astDOTtype_param]:
+        return isinstance(node, astDOTtype_param)
+
+    @staticmethod
+    def TypeAlias(node: ast.AST) -> TypeGuard[astDOTTypeAlias]:
+        return isinstance(node, astDOTTypeAlias)
+
+    @staticmethod
+    def TypeIgnore(node: ast.AST) -> TypeGuard[ast.TypeIgnore]:
+        return isinstance(node, ast.TypeIgnore)
+
+    @staticmethod
+    def TypeVar(node: ast.AST) -> TypeGuard[astDOTTypeVar]:
+        return isinstance(node, astDOTTypeVar)
+
+    @staticmethod
+    def TypeVarTuple(node: ast.AST) -> TypeGuard[astDOTTypeVarTuple]:
+        return isinstance(node, astDOTTypeVarTuple)
+
+    @staticmethod
+    def UAdd(node: ast.AST) -> TypeGuard[ast.UAdd]:
+        return isinstance(node, ast.UAdd)
+
+    @staticmethod
+    def UnaryOp(node: ast.AST) -> TypeGuard[ast.UnaryOp]:
+        return isinstance(node, ast.UnaryOp)
+
+    @staticmethod
+    def unaryop(node: ast.AST) -> TypeGuard[ast.unaryop]:
+        return isinstance(node, ast.unaryop)
+
+    @staticmethod
+    def USub(node: ast.AST) -> TypeGuard[ast.USub]:
+        return isinstance(node, ast.USub)
+
+    @staticmethod
+    def While(node: ast.AST) -> TypeGuard[ast.While]:
+        return isinstance(node, ast.While)
+
+    @staticmethod
+    def With(node: ast.AST) -> TypeGuard[ast.With]:
+        return isinstance(node, ast.With)
+
+    @staticmethod
+    def withitem(node: ast.AST) -> TypeGuard[ast.withitem]:
+        return isinstance(node, ast.withitem)
+
+    @staticmethod
+    def Yield(node: ast.AST) -> TypeGuard[ast.Yield]:
+        return isinstance(node, ast.Yield)
+
+    @staticmethod
+    def YieldFrom(node: ast.AST) -> TypeGuard[ast.YieldFrom]:
+        return isinstance(node, ast.YieldFrom)