DOT can return None or Sequence[None]

Author: hunterhogan

astToolkit/_toolBe.py

@@ -132,14 +132,14 @@ def BitOr(node: ast.AST) -> TypeIs[ast.BitOr]:
     def BitXor(node: ast.AST) -> TypeIs[ast.BitXor]:
         return isinstance(node, ast.BitXor)
 
-    @staticmethod
-    def BoolOp(node: ast.AST) -> TypeIs[ast.BoolOp]:
-        return isinstance(node, ast.BoolOp)
-
     @staticmethod
     def boolop(node: ast.AST) -> TypeIs[ast.boolop]:
         return isinstance(node, ast.boolop)
 
+    @staticmethod
+    def BoolOp(node: ast.AST) -> TypeIs[ast.BoolOp]:
+        return isinstance(node, ast.BoolOp)
+
     @staticmethod
     def Break(node: ast.AST) -> TypeIs[ast.Break]:
         return isinstance(node, ast.Break)
@@ -196,22 +196,22 @@ def Div(node: ast.AST) -> TypeIs[ast.Div]:
     def Eq(node: ast.AST) -> TypeIs[ast.Eq]:
         return isinstance(node, ast.Eq)
 
-    @staticmethod
-    def ExceptHandler(node: ast.AST) -> TypeIs[ast.ExceptHandler]:
-        return isinstance(node, ast.ExceptHandler)
-
     @staticmethod
     def excepthandler(node: ast.AST) -> TypeIs[ast.excepthandler]:
         return isinstance(node, ast.excepthandler)
 
     @staticmethod
-    def Expr(node: ast.AST) -> TypeIs[ast.Expr]:
-        return isinstance(node, ast.Expr)
+    def ExceptHandler(node: ast.AST) -> TypeIs[ast.ExceptHandler]:
+        return isinstance(node, ast.ExceptHandler)
 
     @staticmethod
     def expr(node: ast.AST) -> TypeIs[ast.expr]:
         return isinstance(node, ast.expr)
 
+    @staticmethod
+    def Expr(node: ast.AST) -> TypeIs[ast.Expr]:
+        return isinstance(node, ast.Expr)
+
     @staticmethod
     def expr_context(node: ast.AST) -> TypeIs[ast.expr_context]:
         return isinstance(node, ast.expr_context)
@@ -372,14 +372,14 @@ def MatchValue(node: ast.AST) -> TypeIs[ast.MatchValue]:
     def MatMult(node: ast.AST) -> TypeIs[ast.MatMult]:
         return isinstance(node, ast.MatMult)
 
-    @staticmethod
-    def Mod(node: ast.AST) -> TypeIs[ast.Mod]:
-        return isinstance(node, ast.Mod)
-
     @staticmethod
     def mod(node: ast.AST) -> TypeIs[ast.mod]:
         return isinstance(node, ast.mod)
 
+    @staticmethod
+    def Mod(node: ast.AST) -> TypeIs[ast.Mod]:
+        return isinstance(node, ast.Mod)
+
     @staticmethod
     def Module(node: ast.AST) -> TypeIs[ast.Module]:
         return isinstance(node, ast.Module)
@@ -520,14 +520,14 @@ def TypeVarTuple(node: ast.AST) -> TypeIs[ast.TypeVarTuple]:
     def UAdd(node: ast.AST) -> TypeIs[ast.UAdd]:
         return isinstance(node, ast.UAdd)
 
-    @staticmethod
-    def UnaryOp(node: ast.AST) -> TypeIs[ast.UnaryOp]:
-        return isinstance(node, ast.UnaryOp)
-
     @staticmethod
     def unaryop(node: ast.AST) -> TypeIs[ast.unaryop]:
         return isinstance(node, ast.unaryop)
 
+    @staticmethod
+    def UnaryOp(node: ast.AST) -> TypeIs[ast.UnaryOp]:
+        return isinstance(node, ast.UnaryOp)
+
     @staticmethod
     def USub(node: ast.AST) -> TypeIs[ast.USub]:
         return isinstance(node, ast.USub)

astToolkit/_toolDOT.py

@@ -1,4 +1,3 @@
-# pyright: reportReturnType=false
 # pyright: reportMatchNotExhaustive=false
 """This file is generated automatically, so changes to this file will be lost."""
 from astToolkit import (
@@ -51,11 +50,11 @@ def annotation(node: hasDOTannotation_expr) -> ast.expr:
 
     @staticmethod
     @overload
-    def annotation(node: hasDOTannotation_exprOrNone) -> ast.expr:
+    def annotation(node: hasDOTannotation_exprOrNone) -> ast.expr | None:
         ...
 
     @staticmethod
-    def annotation(node: hasDOTannotation) -> ast.expr:
+    def annotation(node: hasDOTannotation) -> ast.expr | (ast.expr | None):
         return node.annotation
 
     @staticmethod
@@ -65,11 +64,11 @@ def arg(node: hasDOTarg_str) -> str:
 
     @staticmethod
     @overload
-    def arg(node: hasDOTarg_strOrNone) -> str:
+    def arg(node: hasDOTarg_strOrNone) -> str | None:
         ...
 
     @staticmethod
-    def arg(node: hasDOTarg) -> str:
+    def arg(node: hasDOTarg) -> str | (str | None):
         return node.arg
 
     @staticmethod
@@ -96,7 +95,7 @@ def argtypes(node: hasDOTargtypes) -> Sequence[ast.expr]:
         return node.argtypes
 
     @staticmethod
-    def asname(node: hasDOTasname) -> str:
+    def asname(node: hasDOTasname) -> str | None:
         return node.asname
 
     @staticmethod
@@ -122,15 +121,15 @@ def body(node: hasDOTbody) -> ast.expr | Sequence[ast.stmt]:
         return node.body
 
     @staticmethod
-    def bound(node: hasDOTbound) -> ast.expr:
+    def bound(node: hasDOTbound) -> ast.expr | None:
         return node.bound
 
     @staticmethod
     def cases(node: hasDOTcases) -> Sequence[ast.match_case]:
         return node.cases
 
     @staticmethod
-    def cause(node: hasDOTcause) -> ast.expr:
+    def cause(node: hasDOTcause) -> ast.expr | None:
         return node.cause
 
     @staticmethod
@@ -160,7 +159,7 @@ def decorator_list(node: hasDOTdecorator_list) -> Sequence[ast.expr]:
         case version if version >= (3, 13):
 
             @staticmethod
-            def default_value(node: hasDOTdefault_value) -> ast.expr:
+            def default_value(node: hasDOTdefault_value) -> ast.expr | None:
                 return node.default_value
 
     @staticmethod
@@ -176,15 +175,15 @@ def elts(node: hasDOTelts) -> Sequence[ast.expr]:
         return node.elts
 
     @staticmethod
-    def exc(node: hasDOTexc) -> ast.expr:
+    def exc(node: hasDOTexc) -> ast.expr | None:
         return node.exc
 
     @staticmethod
     def finalbody(node: hasDOTfinalbody) -> Sequence[ast.stmt]:
         return node.finalbody
 
     @staticmethod
-    def format_spec(node: hasDOTformat_spec) -> ast.expr:
+    def format_spec(node: hasDOTformat_spec) -> ast.expr | None:
         return node.format_spec
 
     @staticmethod
@@ -196,7 +195,7 @@ def generators(node: hasDOTgenerators) -> Sequence[ast.comprehension]:
         return node.generators
 
     @staticmethod
-    def guard(node: hasDOTguard) -> ast.expr:
+    def guard(node: hasDOTguard) -> ast.expr | None:
         return node.guard
 
     @staticmethod
@@ -234,27 +233,27 @@ def keys(node: hasDOTkeys_list_expr) -> Sequence[ast.expr]:
 
     @staticmethod
     @overload
-    def keys(node: hasDOTkeys_list_exprOrNone) -> Sequence[ast.expr]:
+    def keys(node: hasDOTkeys_list_exprOrNone) -> Sequence[ast.expr | None]:
         ...
 
     @staticmethod
-    def keys(node: hasDOTkeys) -> Sequence[ast.expr]:
+    def keys(node: hasDOTkeys) -> Sequence[ast.expr | None] | Sequence[ast.expr]:
         return node.keys
 
     @staticmethod
     def keywords(node: hasDOTkeywords) -> Sequence[ast.keyword]:
         return node.keywords
 
     @staticmethod
-    def kind(node: hasDOTkind) -> str:
+    def kind(node: hasDOTkind) -> str | None:
         return node.kind
 
     @staticmethod
-    def kw_defaults(node: hasDOTkw_defaults) -> Sequence[ast.expr]:
+    def kw_defaults(node: hasDOTkw_defaults) -> Sequence[ast.expr | None]:
         return node.kw_defaults
 
     @staticmethod
-    def kwarg(node: hasDOTkwarg) -> ast.arg:
+    def kwarg(node: hasDOTkwarg) -> ast.arg | None:
         return node.kwarg
 
     @staticmethod
@@ -282,15 +281,15 @@ def lineno(node: hasDOTlineno) -> int:
         return node.lineno
 
     @staticmethod
-    def lower(node: hasDOTlower) -> ast.expr:
+    def lower(node: hasDOTlower) -> ast.expr | None:
         return node.lower
 
     @staticmethod
-    def module(node: hasDOTmodule) -> str:
+    def module(node: hasDOTmodule) -> str | None:
         return node.module
 
     @staticmethod
-    def msg(node: hasDOTmsg) -> ast.expr:
+    def msg(node: hasDOTmsg) -> ast.expr | None:
         return node.msg
 
     @staticmethod
@@ -305,11 +304,11 @@ def name(node: hasDOTname_str) -> str:
 
     @staticmethod
     @overload
-    def name(node: hasDOTname_strOrNone) -> str:
+    def name(node: hasDOTname_strOrNone) -> str | None:
         ...
 
     @staticmethod
-    def name(node: hasDOTname) -> ast.Name | str:
+    def name(node: hasDOTname) -> ast.Name | str | (str | None):
         return node.name
 
     @staticmethod
@@ -354,7 +353,7 @@ def ops(node: hasDOTops) -> Sequence[ast.cmpop]:
         return node.ops
 
     @staticmethod
-    def optional_vars(node: hasDOToptional_vars) -> ast.expr:
+    def optional_vars(node: hasDOToptional_vars) -> ast.expr | None:
         return node.optional_vars
 
     @staticmethod
@@ -378,11 +377,11 @@ def pattern(node: hasDOTpattern_pattern) -> ast.pattern:
 
     @staticmethod
     @overload
-    def pattern(node: hasDOTpattern_patternOrNone) -> ast.pattern:
+    def pattern(node: hasDOTpattern_patternOrNone) -> ast.pattern | None:
         ...
 
     @staticmethod
-    def pattern(node: hasDOTpattern) -> ast.pattern:
+    def pattern(node: hasDOTpattern) -> ast.pattern | (ast.pattern | None):
         return node.pattern
 
     @staticmethod
@@ -394,7 +393,7 @@ def posonlyargs(node: hasDOTposonlyargs) -> list[ast.arg]:
         return node.posonlyargs
 
     @staticmethod
-    def rest(node: hasDOTrest) -> str:
+    def rest(node: hasDOTrest) -> str | None:
         return node.rest
 
     @staticmethod
@@ -404,11 +403,11 @@ def returns(node: hasDOTreturns_expr) -> ast.expr:
 
     @staticmethod
     @overload
-    def returns(node: hasDOTreturns_exprOrNone) -> ast.expr:
+    def returns(node: hasDOTreturns_exprOrNone) -> ast.expr | None:
         ...
 
     @staticmethod
-    def returns(node: hasDOTreturns) -> ast.expr:
+    def returns(node: hasDOTreturns) -> ast.expr | (ast.expr | None):
         return node.returns
 
     @staticmethod
@@ -424,7 +423,7 @@ def slice(node: hasDOTslice) -> ast.expr:
         return node.slice
 
     @staticmethod
-    def step(node: hasDOTstep) -> ast.expr:
+    def step(node: hasDOTstep) -> ast.expr | None:
         return node.step
 
     @staticmethod
@@ -463,11 +462,11 @@ def test(node: hasDOTtest) -> ast.expr:
         return node.test
 
     @staticmethod
-    def type(node: hasDOTtype) -> ast.expr:
+    def type(node: hasDOTtype) -> ast.expr | None:
         return node.type
 
     @staticmethod
-    def type_comment(node: hasDOTtype_comment) -> str:
+    def type_comment(node: hasDOTtype_comment) -> str | None:
         return node.type_comment
 
     @staticmethod
@@ -479,12 +478,12 @@ def type_params(node: hasDOTtype_params) -> Sequence[ast.type_param]:
         return node.type_params
 
     @staticmethod
-    def upper(node: hasDOTupper) -> ast.expr:
+    def upper(node: hasDOTupper) -> ast.expr | None:
         return node.upper
 
     @staticmethod
     @overload
-    def value(node: hasDOTvalue_boolOrNone) -> bool:
+    def value(node: hasDOTvalue_boolOrNone) -> bool | None:
         ...
 
     @staticmethod
@@ -499,17 +498,17 @@ def value(node: hasDOTvalue_expr) -> ast.expr:
 
     @staticmethod
     @overload
-    def value(node: hasDOTvalue_exprOrNone) -> ast.expr:
+    def value(node: hasDOTvalue_exprOrNone) -> ast.expr | None:
         ...
 
     @staticmethod
-    def value(node: hasDOTvalue) -> ast.expr | bool | ConstantValueType:
+    def value(node: hasDOTvalue) -> ast.expr | (ast.expr | None) | (bool | None) | ConstantValueType:
         return node.value
 
     @staticmethod
     def values(node: hasDOTvalues) -> Sequence[ast.expr]:
         return node.values
 
     @staticmethod
-    def vararg(node: hasDOTvararg) -> ast.arg:
+    def vararg(node: hasDOTvararg) -> ast.arg | None:
         return node.vararg