pyre-check-nightly 0.0.101729941099__py3-none-manylinux1_x86_64.whl → 0.0.101730459520__py3-none-manylinux1_x86_64.whl

pyre_check_nightly-0.0.101729941099.data/data/lib/pyre_check/typeshed/stdlib/_ast.pyi → pyre_check_nightly-0.0.101730459520.data/data/lib/pyre_check/typeshed/stdlib/ast.pyi

@@ -1,17 +1,18 @@
+import os
 import sys
 import typing_extensions
-from typing import Any, ClassVar, Generic, Literal, TypedDict, overload
-from typing_extensions import Self, Unpack
-
-PyCF_ONLY_AST: Literal[1024]
-PyCF_TYPE_COMMENTS: Literal[4096]
-PyCF_ALLOW_TOP_LEVEL_AWAIT: Literal[8192]
+from _ast import (
+    PyCF_ALLOW_TOP_LEVEL_AWAIT as PyCF_ALLOW_TOP_LEVEL_AWAIT,
+    PyCF_ONLY_AST as PyCF_ONLY_AST,
+    PyCF_TYPE_COMMENTS as PyCF_TYPE_COMMENTS,
+)
+from _typeshed import ReadableBuffer, Unused
+from collections.abc import Iterator
+from typing import Any, ClassVar, Generic, Literal, TypedDict, TypeVar as _TypeVar, overload
+from typing_extensions import Self, Unpack, deprecated
 
 if sys.version_info >= (3, 13):
-    PyCF_OPTIMIZED_AST: Literal[33792]
-
-# Used for node end positions in constructor keyword arguments
-_EndPositionT = typing_extensions.TypeVar("_EndPositionT", int, int | None, default=int | None)
+    from _ast import PyCF_OPTIMIZED_AST as PyCF_OPTIMIZED_AST
 
 # Alias used for fields that must always be valid identifiers
 # A string `x` counts as a valid identifier if both the following are True
@@ -19,6 +20,9 @@ _EndPositionT = typing_extensions.TypeVar("_EndPositionT", int, int | None, defa
 # (2) `keyword.iskeyword(x)` evaluates to `False`
 _Identifier: typing_extensions.TypeAlias = str
 
+# Used for node end positions in constructor keyword arguments
+_EndPositionT = typing_extensions.TypeVar("_EndPositionT", int, int | None, default=int | None)
+
 # Corresponds to the names in the `_attributes` class variable which is non-empty in certain AST nodes
 class _Attributes(TypedDict, Generic[_EndPositionT], total=False):
     lineno: int
@@ -26,6 +30,9 @@ class _Attributes(TypedDict, Generic[_EndPositionT], total=False):
     end_lineno: _EndPositionT
     end_col_offset: _EndPositionT
 
+# The various AST classes are implemented in C, and imported from _ast at runtime,
+# but they consider themselves to live in the ast module,
+# so we'll define the stubs in this file.
 class AST:
     if sys.version_info >= (3, 10):
         __match_args__ = ()
@@ -38,33 +45,6 @@ class AST:
         def __replace__(self) -> Self: ...
 
 class mod(AST): ...
-class type_ignore(AST): ...
-
-class TypeIgnore(type_ignore):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("lineno", "tag")
-    lineno: int
-    tag: str
-    def __init__(self, lineno: int, tag: str) -> None: ...
-
-    if sys.version_info >= (3, 14):
-        def __replace__(self, *, lineno: int = ..., tag: str = ...) -> Self: ...
-
-class FunctionType(mod):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("argtypes", "returns")
-    argtypes: list[expr]
-    returns: expr
-    if sys.version_info >= (3, 13):
-        @overload
-        def __init__(self, argtypes: list[expr], returns: expr) -> None: ...
-        @overload
-        def __init__(self, argtypes: list[expr] = ..., *, returns: expr) -> None: ...
-    else:
-        def __init__(self, argtypes: list[expr], returns: expr) -> None: ...
-
-    if sys.version_info >= (3, 14):
-        def __replace__(self, *, argtypes: list[expr] = ..., returns: expr = ...) -> Self: ...
 
 class Module(mod):
     if sys.version_info >= (3, 10):
@@ -100,6 +80,22 @@ class Expression(mod):
     if sys.version_info >= (3, 14):
         def __replace__(self, *, body: expr = ...) -> Self: ...
 
+class FunctionType(mod):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("argtypes", "returns")
+    argtypes: list[expr]
+    returns: expr
+    if sys.version_info >= (3, 13):
+        @overload
+        def __init__(self, argtypes: list[expr], returns: expr) -> None: ...
+        @overload
+        def __init__(self, argtypes: list[expr] = ..., *, returns: expr) -> None: ...
+    else:
+        def __init__(self, argtypes: list[expr], returns: expr) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, argtypes: list[expr] = ..., returns: expr = ...) -> Self: ...
+
 class stmt(AST):
     lineno: int
     col_offset: int
@@ -366,6 +362,36 @@ class Assign(stmt):
             self, *, targets: list[expr] = ..., value: expr = ..., type_comment: str | None = ..., **kwargs: Unpack[_Attributes]
         ) -> Self: ...
 
+if sys.version_info >= (3, 12):
+    class TypeAlias(stmt):
+        __match_args__ = ("name", "type_params", "value")
+        name: Name
+        type_params: list[type_param]
+        value: expr
+        if sys.version_info >= (3, 13):
+            @overload
+            def __init__(
+                self, name: Name, type_params: list[type_param], value: expr, **kwargs: Unpack[_Attributes[int]]
+            ) -> None: ...
+            @overload
+            def __init__(
+                self, name: Name, type_params: list[type_param] = ..., *, value: expr, **kwargs: Unpack[_Attributes[int]]
+            ) -> None: ...
+        else:
+            def __init__(
+                self, name: Name, type_params: list[type_param], value: expr, **kwargs: Unpack[_Attributes[int]]
+            ) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self,
+                *,
+                name: Name = ...,
+                type_params: list[type_param] = ...,
+                value: expr = ...,
+                **kwargs: Unpack[_Attributes[int]],
+            ) -> Self: ...
+
 class AugAssign(stmt):
     if sys.version_info >= (3, 10):
         __match_args__ = ("target", "op", "value")
@@ -598,6 +624,21 @@ class AsyncWith(stmt):
             **kwargs: Unpack[_Attributes],
         ) -> Self: ...
 
+if sys.version_info >= (3, 10):
+    class Match(stmt):
+        __match_args__ = ("subject", "cases")
+        subject: expr
+        cases: list[match_case]
+        if sys.version_info >= (3, 13):
+            def __init__(self, subject: expr, cases: list[match_case] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+        else:
+            def __init__(self, subject: expr, cases: list[match_case], **kwargs: Unpack[_Attributes]) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(
+                self, *, subject: expr = ..., cases: list[match_case] = ..., **kwargs: Unpack[_Attributes]
+            ) -> Self: ...
+
 class Raise(stmt):
     if sys.version_info >= (3, 10):
         __match_args__ = ("exc", "cause")
@@ -790,6 +831,16 @@ class BoolOp(expr):
     if sys.version_info >= (3, 14):
         def __replace__(self, *, op: boolop = ..., values: list[expr] = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
 
+class NamedExpr(expr):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("target", "value")
+    target: Name
+    value: expr
+    def __init__(self, target: Name, value: expr, **kwargs: Unpack[_Attributes]) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, target: Name = ..., value: expr = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
+
 class BinOp(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("left", "op", "right")
@@ -1029,16 +1080,6 @@ class Constant(expr):
     if sys.version_info >= (3, 14):
         def __replace__(self, *, value: Any = ..., kind: str | None = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
 
-class NamedExpr(expr):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("target", "value")
-    target: Name
-    value: expr
-    def __init__(self, target: Name, value: expr, **kwargs: Unpack[_Attributes]) -> None: ...
-
-    if sys.version_info >= (3, 14):
-        def __replace__(self, *, target: Name = ..., value: expr = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
-
 class Attribute(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("value", "attr", "ctx")
@@ -1052,44 +1093,6 @@ class Attribute(expr):
             self, *, value: expr = ..., attr: _Identifier = ..., ctx: expr_context = ..., **kwargs: Unpack[_Attributes]
         ) -> Self: ...
 
-if sys.version_info >= (3, 9):
-    _Slice: typing_extensions.TypeAlias = expr
-    _SliceAttributes: typing_extensions.TypeAlias = _Attributes
-else:
-    class slice(AST): ...
-    _Slice: typing_extensions.TypeAlias = slice
-
-    class _SliceAttributes(TypedDict): ...
-
-class Slice(_Slice):
-    if sys.version_info >= (3, 10):
-        __match_args__ = ("lower", "upper", "step")
-    lower: expr | None
-    upper: expr | None
-    step: expr | None
-    def __init__(
-        self, lower: expr | None = None, upper: expr | None = None, step: expr | None = None, **kwargs: Unpack[_SliceAttributes]
-    ) -> None: ...
-
-    if sys.version_info >= (3, 14):
-        def __replace__(
-            self,
-            *,
-            lower: expr | None = ...,
-            upper: expr | None = ...,
-            step: expr | None = ...,
-            **kwargs: Unpack[_SliceAttributes],
-        ) -> Self: ...
-
-if sys.version_info < (3, 9):
-    class ExtSlice(slice):
-        dims: list[slice]
-        def __init__(self, dims: list[slice], **kwargs: Unpack[_SliceAttributes]) -> None: ...
-
-    class Index(slice):
-        value: expr
-        def __init__(self, value: expr, **kwargs: Unpack[_SliceAttributes]) -> None: ...
-
 class Subscript(expr):
     if sys.version_info >= (3, 10):
         __match_args__ = ("value", "slice", "ctx")
@@ -1151,37 +1154,74 @@ class Tuple(expr):
     if sys.version_info >= (3, 14):
         def __replace__(self, *, elts: list[expr] = ..., ctx: expr_context = ..., **kwargs: Unpack[_Attributes]) -> Self: ...
 
-class expr_context(AST): ...
+class slice(AST): ...  # deprecated and moved to ast.py for >= (3, 9)
 
-if sys.version_info < (3, 9):
-    class AugLoad(expr_context): ...
-    class AugStore(expr_context): ...
-    class Param(expr_context): ...
+if sys.version_info >= (3, 9):
+    _Slice: typing_extensions.TypeAlias = expr
+    _SliceAttributes: typing_extensions.TypeAlias = _Attributes
+else:
+    # alias for use with variables named slice
+    _Slice: typing_extensions.TypeAlias = slice
 
-    class Suite(mod):
-        body: list[stmt]
-        def __init__(self, body: list[stmt]) -> None: ...
+    class _SliceAttributes(TypedDict): ...
+
+class Slice(_Slice):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("lower", "upper", "step")
+    lower: expr | None
+    upper: expr | None
+    step: expr | None
+    def __init__(
+        self, lower: expr | None = None, upper: expr | None = None, step: expr | None = None, **kwargs: Unpack[_SliceAttributes]
+    ) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(
+            self,
+            *,
+            lower: expr | None = ...,
+            upper: expr | None = ...,
+            step: expr | None = ...,
+            **kwargs: Unpack[_SliceAttributes],
+        ) -> Self: ...
+
+class ExtSlice(slice):  # deprecated and moved to ast.py if sys.version_info >= (3, 9)
+    dims: list[slice]
+    def __init__(self, dims: list[slice], **kwargs: Unpack[_SliceAttributes]) -> None: ...
+
+class Index(slice):  # deprecated and moved to ast.py if sys.version_info >= (3, 9)
+    value: expr
+    def __init__(self, value: expr, **kwargs: Unpack[_SliceAttributes]) -> None: ...
+
+class expr_context(AST): ...
+class AugLoad(expr_context): ...  # deprecated and moved to ast.py if sys.version_info >= (3, 9)
+class AugStore(expr_context): ...  # deprecated and moved to ast.py if sys.version_info >= (3, 9)
+class Param(expr_context): ...  # deprecated and moved to ast.py if sys.version_info >= (3, 9)
+
+class Suite(mod):  # deprecated and moved to ast.py if sys.version_info >= (3, 9)
+    body: list[stmt]
+    def __init__(self, body: list[stmt]) -> None: ...
 
-class Del(expr_context): ...
 class Load(expr_context): ...
 class Store(expr_context): ...
+class Del(expr_context): ...
 class boolop(AST): ...
 class And(boolop): ...
 class Or(boolop): ...
 class operator(AST): ...
 class Add(operator): ...
-class BitAnd(operator): ...
-class BitOr(operator): ...
-class BitXor(operator): ...
-class Div(operator): ...
-class FloorDiv(operator): ...
-class LShift(operator): ...
-class Mod(operator): ...
+class Sub(operator): ...
 class Mult(operator): ...
 class MatMult(operator): ...
+class Div(operator): ...
+class Mod(operator): ...
 class Pow(operator): ...
+class LShift(operator): ...
 class RShift(operator): ...
-class Sub(operator): ...
+class BitOr(operator): ...
+class BitXor(operator): ...
+class BitAnd(operator): ...
+class FloorDiv(operator): ...
 class unaryop(AST): ...
 class Invert(unaryop): ...
 class Not(unaryop): ...
@@ -1189,14 +1229,14 @@ class UAdd(unaryop): ...
 class USub(unaryop): ...
 class cmpop(AST): ...
 class Eq(cmpop): ...
+class NotEq(cmpop): ...
+class Lt(cmpop): ...
+class LtE(cmpop): ...
 class Gt(cmpop): ...
 class GtE(cmpop): ...
-class In(cmpop): ...
 class Is(cmpop): ...
 class IsNot(cmpop): ...
-class Lt(cmpop): ...
-class LtE(cmpop): ...
-class NotEq(cmpop): ...
+class In(cmpop): ...
 class NotIn(cmpop): ...
 
 class comprehension(AST):
@@ -1396,19 +1436,21 @@ class withitem(AST):
         def __replace__(self, *, context_expr: expr = ..., optional_vars: expr | None = ...) -> Self: ...
 
 if sys.version_info >= (3, 10):
-    class Match(stmt):
-        __match_args__ = ("subject", "cases")
-        subject: expr
-        cases: list[match_case]
+    class match_case(AST):
+        __match_args__ = ("pattern", "guard", "body")
+        pattern: _Pattern
+        guard: expr | None
+        body: list[stmt]
         if sys.version_info >= (3, 13):
-            def __init__(self, subject: expr, cases: list[match_case] = ..., **kwargs: Unpack[_Attributes]) -> None: ...
+            def __init__(self, pattern: _Pattern, guard: expr | None = None, body: list[stmt] = ...) -> None: ...
         else:
-            def __init__(self, subject: expr, cases: list[match_case], **kwargs: Unpack[_Attributes]) -> None: ...
+            @overload
+            def __init__(self, pattern: _Pattern, guard: expr | None, body: list[stmt]) -> None: ...
+            @overload
+            def __init__(self, pattern: _Pattern, guard: expr | None = None, *, body: list[stmt]) -> None: ...
 
         if sys.version_info >= (3, 14):
-            def __replace__(
-                self, *, subject: expr = ..., cases: list[match_case] = ..., **kwargs: Unpack[_Attributes]
-            ) -> Self: ...
+            def __replace__(self, *, pattern: _Pattern = ..., guard: expr | None = ..., body: list[stmt] = ...) -> Self: ...
 
     class pattern(AST):
         lineno: int
@@ -1425,22 +1467,6 @@ if sys.version_info >= (3, 10):
     # Without the alias, Pyright complains variables named pattern are recursively defined
     _Pattern: typing_extensions.TypeAlias = pattern
 
-    class match_case(AST):
-        __match_args__ = ("pattern", "guard", "body")
-        pattern: _Pattern
-        guard: expr | None
-        body: list[stmt]
-        if sys.version_info >= (3, 13):
-            def __init__(self, pattern: _Pattern, guard: expr | None = None, body: list[stmt] = ...) -> None: ...
-        else:
-            @overload
-            def __init__(self, pattern: _Pattern, guard: expr | None, body: list[stmt]) -> None: ...
-            @overload
-            def __init__(self, pattern: _Pattern, guard: expr | None = None, *, body: list[stmt]) -> None: ...
-
-        if sys.version_info >= (3, 14):
-            def __replace__(self, *, pattern: _Pattern = ..., guard: expr | None = ..., body: list[stmt] = ...) -> Self: ...
-
     class MatchValue(pattern):
         __match_args__ = ("value",)
         value: expr
@@ -1468,14 +1494,6 @@ if sys.version_info >= (3, 10):
         if sys.version_info >= (3, 14):
             def __replace__(self, *, patterns: list[pattern] = ..., **kwargs: Unpack[_Attributes[int]]) -> Self: ...
 
-    class MatchStar(pattern):
-        __match_args__ = ("name",)
-        name: _Identifier | None
-        def __init__(self, name: _Identifier | None, **kwargs: Unpack[_Attributes[int]]) -> None: ...
-
-        if sys.version_info >= (3, 14):
-            def __replace__(self, *, name: _Identifier | None = ..., **kwargs: Unpack[_Attributes[int]]) -> Self: ...
-
     class MatchMapping(pattern):
         __match_args__ = ("keys", "patterns", "rest")
         keys: list[expr]
@@ -1544,6 +1562,14 @@ if sys.version_info >= (3, 10):
                 **kwargs: Unpack[_Attributes[int]],
             ) -> Self: ...
 
+    class MatchStar(pattern):
+        __match_args__ = ("name",)
+        name: _Identifier | None
+        def __init__(self, name: _Identifier | None, **kwargs: Unpack[_Attributes[int]]) -> None: ...
+
+        if sys.version_info >= (3, 14):
+            def __replace__(self, *, name: _Identifier | None = ..., **kwargs: Unpack[_Attributes[int]]) -> Self: ...
+
     class MatchAs(pattern):
         __match_args__ = ("pattern", "name")
         pattern: _Pattern | None
@@ -1568,6 +1594,18 @@ if sys.version_info >= (3, 10):
         if sys.version_info >= (3, 14):
             def __replace__(self, *, patterns: list[pattern] = ..., **kwargs: Unpack[_Attributes[int]]) -> Self: ...
 
+class type_ignore(AST): ...
+
+class TypeIgnore(type_ignore):
+    if sys.version_info >= (3, 10):
+        __match_args__ = ("lineno", "tag")
+    lineno: int
+    tag: str
+    def __init__(self, lineno: int, tag: str) -> None: ...
+
+    if sys.version_info >= (3, 14):
+        def __replace__(self, *, lineno: int = ..., tag: str = ...) -> Self: ...
+
 if sys.version_info >= (3, 12):
     class type_param(AST):
         lineno: int
@@ -1646,31 +1684,366 @@ if sys.version_info >= (3, 12):
                 self, *, name: _Identifier = ..., default_value: expr | None = ..., **kwargs: Unpack[_Attributes[int]]
             ) -> Self: ...
 
-    class TypeAlias(stmt):
-        __match_args__ = ("name", "type_params", "value")
-        name: Name
-        type_params: list[type_param]
-        value: expr
-        if sys.version_info >= (3, 13):
-            @overload
-            def __init__(
-                self, name: Name, type_params: list[type_param], value: expr, **kwargs: Unpack[_Attributes[int]]
-            ) -> None: ...
-            @overload
-            def __init__(
-                self, name: Name, type_params: list[type_param] = ..., *, value: expr, **kwargs: Unpack[_Attributes[int]]
-            ) -> None: ...
-        else:
-            def __init__(
-                self, name: Name, type_params: list[type_param], value: expr, **kwargs: Unpack[_Attributes[int]]
-            ) -> None: ...
+class _ABC(type):
+    if sys.version_info >= (3, 9):
+        def __init__(cls, *args: Unused) -> None: ...
 
-        if sys.version_info >= (3, 14):
-            def __replace__(
-                self,
-                *,
-                name: Name = ...,
-                type_params: list[type_param] = ...,
-                value: expr = ...,
-                **kwargs: Unpack[_Attributes[int]],
-            ) -> Self: ...
+if sys.version_info < (3, 14):
+    @deprecated("Replaced by ast.Constant; removed in Python 3.14")
+    class Num(Constant, metaclass=_ABC):
+        value: int | float | complex
+
+    @deprecated("Replaced by ast.Constant; removed in Python 3.14")
+    class Str(Constant, metaclass=_ABC):
+        value: str
+        # Aliases for value, for backwards compatibility
+        s: str
+
+    @deprecated("Replaced by ast.Constant; removed in Python 3.14")
+    class Bytes(Constant, metaclass=_ABC):
+        value: bytes
+        # Aliases for value, for backwards compatibility
+        s: bytes
+
+    @deprecated("Replaced by ast.Constant; removed in Python 3.14")
+    class NameConstant(Constant, metaclass=_ABC): ...
+
+    @deprecated("Replaced by ast.Constant; removed in Python 3.14")
+    class Ellipsis(Constant, metaclass=_ABC): ...
+
+# everything below here is defined in ast.py
+
+_T = _TypeVar("_T", bound=AST)
+
+if sys.version_info >= (3, 13):
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any] = "<unknown>",
+        mode: Literal["exec"] = "exec",
+        *,
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+        optimize: Literal[-1, 0, 1, 2] = -1,
+    ) -> Module: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any],
+        mode: Literal["eval"],
+        *,
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+        optimize: Literal[-1, 0, 1, 2] = -1,
+    ) -> Expression: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any],
+        mode: Literal["func_type"],
+        *,
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+        optimize: Literal[-1, 0, 1, 2] = -1,
+    ) -> FunctionType: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any],
+        mode: Literal["single"],
+        *,
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+        optimize: Literal[-1, 0, 1, 2] = -1,
+    ) -> Interactive: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        *,
+        mode: Literal["eval"],
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+        optimize: Literal[-1, 0, 1, 2] = -1,
+    ) -> Expression: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        *,
+        mode: Literal["func_type"],
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+        optimize: Literal[-1, 0, 1, 2] = -1,
+    ) -> FunctionType: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        *,
+        mode: Literal["single"],
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+        optimize: Literal[-1, 0, 1, 2] = -1,
+    ) -> Interactive: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any] = "<unknown>",
+        mode: str = "exec",
+        *,
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+        optimize: Literal[-1, 0, 1, 2] = -1,
+    ) -> AST: ...
+
+else:
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any] = "<unknown>",
+        mode: Literal["exec"] = "exec",
+        *,
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+    ) -> Module: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any],
+        mode: Literal["eval"],
+        *,
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+    ) -> Expression: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any],
+        mode: Literal["func_type"],
+        *,
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+    ) -> FunctionType: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any],
+        mode: Literal["single"],
+        *,
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+    ) -> Interactive: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        *,
+        mode: Literal["eval"],
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+    ) -> Expression: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        *,
+        mode: Literal["func_type"],
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+    ) -> FunctionType: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        *,
+        mode: Literal["single"],
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+    ) -> Interactive: ...
+    @overload
+    def parse(
+        source: str | ReadableBuffer,
+        filename: str | ReadableBuffer | os.PathLike[Any] = "<unknown>",
+        mode: str = "exec",
+        *,
+        type_comments: bool = False,
+        feature_version: None | int | tuple[int, int] = None,
+    ) -> AST: ...
+
+def literal_eval(node_or_string: str | AST) -> Any: ...
+
+if sys.version_info >= (3, 13):
+    def dump(
+        node: AST,
+        annotate_fields: bool = True,
+        include_attributes: bool = False,
+        *,
+        indent: int | str | None = None,
+        show_empty: bool = False,
+    ) -> str: ...
+
+elif sys.version_info >= (3, 9):
+    def dump(
+        node: AST, annotate_fields: bool = True, include_attributes: bool = False, *, indent: int | str | None = None
+    ) -> str: ...
+
+else:
+    def dump(node: AST, annotate_fields: bool = True, include_attributes: bool = False) -> str: ...
+
+def copy_location(new_node: _T, old_node: AST) -> _T: ...
+def fix_missing_locations(node: _T) -> _T: ...
+def increment_lineno(node: _T, n: int = 1) -> _T: ...
+def iter_fields(node: AST) -> Iterator[tuple[str, Any]]: ...
+def iter_child_nodes(node: AST) -> Iterator[AST]: ...
+def get_docstring(node: AsyncFunctionDef | FunctionDef | ClassDef | Module, clean: bool = True) -> str | None: ...
+def get_source_segment(source: str, node: AST, *, padded: bool = False) -> str | None: ...
+def walk(node: AST) -> Iterator[AST]: ...
+
+if sys.version_info >= (3, 14):
+    def compare(left: AST, right: AST, /, *, compare_attributes: bool = False) -> bool: ...
+
+class NodeVisitor:
+    def visit(self, node: AST) -> Any: ...
+    def generic_visit(self, node: AST) -> Any: ...
+    def visit_Module(self, node: Module) -> Any: ...
+    def visit_Interactive(self, node: Interactive) -> Any: ...
+    def visit_Expression(self, node: Expression) -> Any: ...
+    def visit_FunctionDef(self, node: FunctionDef) -> Any: ...
+    def visit_AsyncFunctionDef(self, node: AsyncFunctionDef) -> Any: ...
+    def visit_ClassDef(self, node: ClassDef) -> Any: ...
+    def visit_Return(self, node: Return) -> Any: ...
+    def visit_Delete(self, node: Delete) -> Any: ...
+    def visit_Assign(self, node: Assign) -> Any: ...
+    def visit_AugAssign(self, node: AugAssign) -> Any: ...
+    def visit_AnnAssign(self, node: AnnAssign) -> Any: ...
+    def visit_For(self, node: For) -> Any: ...
+    def visit_AsyncFor(self, node: AsyncFor) -> Any: ...
+    def visit_While(self, node: While) -> Any: ...
+    def visit_If(self, node: If) -> Any: ...
+    def visit_With(self, node: With) -> Any: ...
+    def visit_AsyncWith(self, node: AsyncWith) -> Any: ...
+    def visit_Raise(self, node: Raise) -> Any: ...
+    def visit_Try(self, node: Try) -> Any: ...
+    def visit_Assert(self, node: Assert) -> Any: ...
+    def visit_Import(self, node: Import) -> Any: ...
+    def visit_ImportFrom(self, node: ImportFrom) -> Any: ...
+    def visit_Global(self, node: Global) -> Any: ...
+    def visit_Nonlocal(self, node: Nonlocal) -> Any: ...
+    def visit_Expr(self, node: Expr) -> Any: ...
+    def visit_Pass(self, node: Pass) -> Any: ...
+    def visit_Break(self, node: Break) -> Any: ...
+    def visit_Continue(self, node: Continue) -> Any: ...
+    def visit_Slice(self, node: Slice) -> Any: ...
+    def visit_BoolOp(self, node: BoolOp) -> Any: ...
+    def visit_BinOp(self, node: BinOp) -> Any: ...
+    def visit_UnaryOp(self, node: UnaryOp) -> Any: ...
+    def visit_Lambda(self, node: Lambda) -> Any: ...
+    def visit_IfExp(self, node: IfExp) -> Any: ...
+    def visit_Dict(self, node: Dict) -> Any: ...
+    def visit_Set(self, node: Set) -> Any: ...
+    def visit_ListComp(self, node: ListComp) -> Any: ...
+    def visit_SetComp(self, node: SetComp) -> Any: ...
+    def visit_DictComp(self, node: DictComp) -> Any: ...
+    def visit_GeneratorExp(self, node: GeneratorExp) -> Any: ...
+    def visit_Await(self, node: Await) -> Any: ...
+    def visit_Yield(self, node: Yield) -> Any: ...
+    def visit_YieldFrom(self, node: YieldFrom) -> Any: ...
+    def visit_Compare(self, node: Compare) -> Any: ...
+    def visit_Call(self, node: Call) -> Any: ...
+    def visit_FormattedValue(self, node: FormattedValue) -> Any: ...
+    def visit_JoinedStr(self, node: JoinedStr) -> Any: ...
+    def visit_Constant(self, node: Constant) -> Any: ...
+    def visit_NamedExpr(self, node: NamedExpr) -> Any: ...
+    def visit_TypeIgnore(self, node: TypeIgnore) -> Any: ...
+    def visit_Attribute(self, node: Attribute) -> Any: ...
+    def visit_Subscript(self, node: Subscript) -> Any: ...
+    def visit_Starred(self, node: Starred) -> Any: ...
+    def visit_Name(self, node: Name) -> Any: ...
+    def visit_List(self, node: List) -> Any: ...
+    def visit_Tuple(self, node: Tuple) -> Any: ...
+    def visit_Del(self, node: Del) -> Any: ...
+    def visit_Load(self, node: Load) -> Any: ...
+    def visit_Store(self, node: Store) -> Any: ...
+    def visit_And(self, node: And) -> Any: ...
+    def visit_Or(self, node: Or) -> Any: ...
+    def visit_Add(self, node: Add) -> Any: ...
+    def visit_BitAnd(self, node: BitAnd) -> Any: ...
+    def visit_BitOr(self, node: BitOr) -> Any: ...
+    def visit_BitXor(self, node: BitXor) -> Any: ...
+    def visit_Div(self, node: Div) -> Any: ...
+    def visit_FloorDiv(self, node: FloorDiv) -> Any: ...
+    def visit_LShift(self, node: LShift) -> Any: ...
+    def visit_Mod(self, node: Mod) -> Any: ...
+    def visit_Mult(self, node: Mult) -> Any: ...
+    def visit_MatMult(self, node: MatMult) -> Any: ...
+    def visit_Pow(self, node: Pow) -> Any: ...
+    def visit_RShift(self, node: RShift) -> Any: ...
+    def visit_Sub(self, node: Sub) -> Any: ...
+    def visit_Invert(self, node: Invert) -> Any: ...
+    def visit_Not(self, node: Not) -> Any: ...
+    def visit_UAdd(self, node: UAdd) -> Any: ...
+    def visit_USub(self, node: USub) -> Any: ...
+    def visit_Eq(self, node: Eq) -> Any: ...
+    def visit_Gt(self, node: Gt) -> Any: ...
+    def visit_GtE(self, node: GtE) -> Any: ...
+    def visit_In(self, node: In) -> Any: ...
+    def visit_Is(self, node: Is) -> Any: ...
+    def visit_IsNot(self, node: IsNot) -> Any: ...
+    def visit_Lt(self, node: Lt) -> Any: ...
+    def visit_LtE(self, node: LtE) -> Any: ...
+    def visit_NotEq(self, node: NotEq) -> Any: ...
+    def visit_NotIn(self, node: NotIn) -> Any: ...
+    def visit_comprehension(self, node: comprehension) -> Any: ...
+    def visit_ExceptHandler(self, node: ExceptHandler) -> Any: ...
+    def visit_arguments(self, node: arguments) -> Any: ...
+    def visit_arg(self, node: arg) -> Any: ...
+    def visit_keyword(self, node: keyword) -> Any: ...
+    def visit_alias(self, node: alias) -> Any: ...
+    def visit_withitem(self, node: withitem) -> Any: ...
+    if sys.version_info >= (3, 10):
+        def visit_Match(self, node: Match) -> Any: ...
+        def visit_match_case(self, node: match_case) -> Any: ...
+        def visit_MatchValue(self, node: MatchValue) -> Any: ...
+        def visit_MatchSequence(self, node: MatchSequence) -> Any: ...
+        def visit_MatchSingleton(self, node: MatchSingleton) -> Any: ...
+        def visit_MatchStar(self, node: MatchStar) -> Any: ...
+        def visit_MatchMapping(self, node: MatchMapping) -> Any: ...
+        def visit_MatchClass(self, node: MatchClass) -> Any: ...
+        def visit_MatchAs(self, node: MatchAs) -> Any: ...
+        def visit_MatchOr(self, node: MatchOr) -> Any: ...
+
+    if sys.version_info >= (3, 11):
+        def visit_TryStar(self, node: TryStar) -> Any: ...
+
+    if sys.version_info >= (3, 12):
+        def visit_TypeVar(self, node: TypeVar) -> Any: ...
+        def visit_ParamSpec(self, node: ParamSpec) -> Any: ...
+        def visit_TypeVarTuple(self, node: TypeVarTuple) -> Any: ...
+        def visit_TypeAlias(self, node: TypeAlias) -> Any: ...
+
+    # visit methods for deprecated nodes
+    def visit_ExtSlice(self, node: ExtSlice) -> Any: ...
+    def visit_Index(self, node: Index) -> Any: ...
+    def visit_Suite(self, node: Suite) -> Any: ...
+    def visit_AugLoad(self, node: AugLoad) -> Any: ...
+    def visit_AugStore(self, node: AugStore) -> Any: ...
+    def visit_Param(self, node: Param) -> Any: ...
+
+    if sys.version_info < (3, 14):
+        @deprecated("Replaced by visit_Constant; removed in Python 3.14")
+        def visit_Num(self, node: Num) -> Any: ...  # type: ignore[deprecated]
+        @deprecated("Replaced by visit_Constant; removed in Python 3.14")
+        def visit_Str(self, node: Str) -> Any: ...  # type: ignore[deprecated]
+        @deprecated("Replaced by visit_Constant; removed in Python 3.14")
+        def visit_Bytes(self, node: Bytes) -> Any: ...  # type: ignore[deprecated]
+        @deprecated("Replaced by visit_Constant; removed in Python 3.14")
+        def visit_NameConstant(self, node: NameConstant) -> Any: ...  # type: ignore[deprecated]
+        @deprecated("Replaced by visit_Constant; removed in Python 3.14")
+        def visit_Ellipsis(self, node: Ellipsis) -> Any: ...  # type: ignore[deprecated]
+
+class NodeTransformer(NodeVisitor):
+    def generic_visit(self, node: AST) -> AST: ...
+    # TODO: Override the visit_* methods with better return types.
+    #       The usual return type is AST | None, but Iterable[AST]
+    #       is also allowed in some cases -- this needs to be mapped.
+
+if sys.version_info >= (3, 9):
+    def unparse(ast_obj: AST) -> str: ...
+
+if sys.version_info >= (3, 9):
+    def main() -> None: ...