basedpyright 1.7.0 → 1.8.0

package/dist/typeshed-fallback/README.md

@@ -10,9 +10,10 @@ Typeshed contains external type annotations for the Python standard library
 and Python builtins, as well as third party packages as contributed by
 people external to those projects.
 
-This data can e.g. be used for static analysis, type checking or type inference.
+This data can e.g. be used for static analysis, type checking, type inference,
+and autocompletion.
 
-For information on how to use `typeshed`, read below.  Information for
+For information on how to use typeshed, read below.  Information for
 contributors can be found in [CONTRIBUTING.md](CONTRIBUTING.md).  **Please read
 it before submitting pull requests; do not report issues with annotations to
 the project the stubs are for, but instead report them here to typeshed.**
@@ -30,15 +31,15 @@ If you're just using a type checker ([mypy](https://github.com/python/mypy/),
 developing it, you don't need to interact with the typeshed repo at
 all: a copy of standard library part of typeshed is bundled with type checkers.
 And type stubs for third party packages and modules you are using can
-be installed from PyPI. For example, if you are using `six` and `requests`,
+be installed from PyPI. For example, if you are using `Pillow` and `requests`,
 you can install the type stubs using
 
 ```bash
-$ pip install types-six types-requests
+$ pip install types-Pillow types-requests
 ```
 
 These PyPI packages follow [PEP 561](http://www.python.org/dev/peps/pep-0561/)
-and are automatically released (multiple times a day, when needed) by
+and are automatically released (up to once a day) by
 [typeshed internal machinery](https://github.com/typeshed-internal/stub_uploader).
 
 Type checkers should be able to use these stub packages when installed. For more
@@ -49,13 +50,11 @@ details, see the documentation for your type checker.
 Version numbers of third-party stub packages consist of at least four parts.
 All parts of the stub version, except for the last part, correspond to the
 version of the runtime package being stubbed. For example, if the `types-foo`
-package has version `1.2.0.7`, this guarantees that the `types-foo` package
+package has version `1.2.0.20240309`, this guarantees that the `types-foo` package
 contains stubs targeted against `foo==1.2.*` and tested against the latest
 version of `foo` matching that specifier. In this example, the final element
-of the version (7) indicates that this is the eighth revision of the stubs for
-`foo==1.2.*`. If an update to the stubs were pushed (but the stubs were still
-aiming to provide annotations for `foo==1.2.*`), then the version of
-`types-foo` would increment to `1.2.0.8`.
+of the version number (20240309) indicates that the stub package was pushed on
+March 9, 2024.
 
 At typeshed, we try to keep breaking changes to a minimum. However, due to the
 nature of stubs, any version bump can introduce changes that might make your
@@ -100,7 +99,7 @@ a problem arises that can't easily be fixed.
 ### The `_typeshed` package
 
 typeshed includes a package `_typeshed` as part of the standard library.
-This package and its submodules contains utility types, but is not
+This package and its submodules contain utility types, but are not
 available at runtime. For more information about how to use this package,
 [see the `stdlib/_typeshed` directory](https://github.com/python/typeshed/tree/main/stdlib/_typeshed).
 

package/dist/typeshed-fallback/commit.txt

@@ -1 +1 @@
-37ebe904ed0413f13e93ce506bfe9042707039f4
+4df0725b4881f2e82defa0f263b561ce867e7919

package/dist/typeshed-fallback/stdlib/builtins.pyi

@@ -1865,6 +1865,7 @@ class MemoryError(Exception): ...
 
 class NameError(Exception):
     if sys.version_info >= (3, 10):
+        def __init__(self, *args: object, name: str | None = ...) -> None: ...
         name: str
 
 class ReferenceError(Exception): ...

package/dist/typeshed-fallback/stdlib/dataclasses.pyi

@@ -243,7 +243,7 @@ class InitVar(Generic[_T], metaclass=_InitVarMeta):
 if sys.version_info >= (3, 12):
     def make_dataclass(
         cls_name: str,
-        fields: Iterable[str | tuple[str, type] | tuple[str, type, Any]],
+        fields: Iterable[str | tuple[str, Any] | tuple[str, Any, Any]],
         *,
         bases: tuple[type, ...] = (),
         namespace: dict[str, Any] | None = None,
@@ -263,7 +263,7 @@ if sys.version_info >= (3, 12):
 elif sys.version_info >= (3, 11):
     def make_dataclass(
         cls_name: str,
-        fields: Iterable[str | tuple[str, type] | tuple[str, type, Any]],
+        fields: Iterable[str | tuple[str, Any] | tuple[str, Any, Any]],
         *,
         bases: tuple[type, ...] = (),
         namespace: dict[str, Any] | None = None,
@@ -282,7 +282,7 @@ elif sys.version_info >= (3, 11):
 elif sys.version_info >= (3, 10):
     def make_dataclass(
         cls_name: str,
-        fields: Iterable[str | tuple[str, type] | tuple[str, type, Any]],
+        fields: Iterable[str | tuple[str, Any] | tuple[str, Any, Any]],
         *,
         bases: tuple[type, ...] = (),
         namespace: dict[str, Any] | None = None,
@@ -300,7 +300,7 @@ elif sys.version_info >= (3, 10):
 else:
     def make_dataclass(
         cls_name: str,
-        fields: Iterable[str | tuple[str, type] | tuple[str, type, Any]],
+        fields: Iterable[str | tuple[str, Any] | tuple[str, Any, Any]],
         *,
         bases: tuple[type, ...] = (),
         namespace: dict[str, Any] | None = None,

package/dist/typeshed-fallback/stdlib/distutils/core.pyi

@@ -53,5 +53,5 @@ def setup(
     password: str = ...,
     fullname: str = ...,
     **attrs: Any,
-) -> None: ...
+) -> Distribution: ...
 def run_setup(script_name: str, script_args: list[str] | None = None, stop_after: str = "run") -> Distribution: ...

package/dist/typeshed-fallback/stdlib/logging/__init__.pyi

@@ -341,6 +341,9 @@ class LogRecord:
     stack_info: str | None
     thread: int | None
     threadName: str | None
+    if sys.version_info >= (3, 12):
+        taskName: str | None
+
     def __init__(
         self,
         name: str,

package/dist/typeshed-fallback/stdlib/optparse.pyi

@@ -1,6 +1,7 @@
+from _typeshed import Incomplete
 from abc import abstractmethod
 from collections.abc import Callable, Iterable, Mapping, Sequence
-from typing import IO, Any, AnyStr, overload
+from typing import IO, Any, AnyStr, Literal, overload
 
 __all__ = [
     "Option",
@@ -26,8 +27,8 @@ NO_DEFAULT: tuple[str, ...]
 SUPPRESS_HELP: str
 SUPPRESS_USAGE: str
 
-def check_builtin(option: Option, opt: Any, value: str) -> Any: ...
-def check_choice(option: Option, opt: Any, value: str) -> str: ...
+def check_builtin(option: Option, opt, value: str): ...
+def check_choice(option: Option, opt, value: str) -> str: ...
 
 class OptParseError(Exception):
     msg: str
@@ -54,26 +55,26 @@ class HelpFormatter:
     _short_opt_fmt: str
     current_indent: int
     default_tag: str
-    help_position: Any
-    help_width: Any
+    help_position: int
+    help_width: int | Any  # initialized as None and computed later as int when storing option strings
     indent_increment: int
     level: int
     max_help_position: int
     option_strings: dict[Option, str]
     parser: OptionParser
-    short_first: Any
+    short_first: Incomplete
     width: int
     def __init__(self, indent_increment: int, max_help_position: int, width: int | None, short_first: int) -> None: ...
     def dedent(self) -> None: ...
     def expand_default(self, option: Option) -> str: ...
-    def format_description(self, description: str) -> str: ...
-    def format_epilog(self, epilog: str) -> str: ...
+    def format_description(self, description: str | None) -> str: ...
+    def format_epilog(self, epilog: str | None) -> str: ...
     @abstractmethod
-    def format_heading(self, heading: Any) -> str: ...
+    def format_heading(self, heading: str) -> str: ...
     def format_option(self, option: Option) -> str: ...
     def format_option_strings(self, option: Option) -> str: ...
     @abstractmethod
-    def format_usage(self, usage: Any) -> str: ...
+    def format_usage(self, usage: str) -> str: ...
     def indent(self) -> None: ...
     def set_long_opt_delimiter(self, delim: str) -> None: ...
     def set_parser(self, parser: OptionParser) -> None: ...
@@ -98,25 +99,25 @@ class Option:
     ACTIONS: tuple[str, ...]
     ALWAYS_TYPED_ACTIONS: tuple[str, ...]
     ATTRS: list[str]
-    CHECK_METHODS: list[Callable[..., Any]] | None
+    CHECK_METHODS: list[Callable[..., Incomplete]] | None
     CONST_ACTIONS: tuple[str, ...]
     STORE_ACTIONS: tuple[str, ...]
     TYPED_ACTIONS: tuple[str, ...]
     TYPES: tuple[str, ...]
-    TYPE_CHECKER: dict[str, Callable[..., Any]]
+    TYPE_CHECKER: dict[str, Callable[[Option, str, Incomplete], Any]]
     _long_opts: list[str]
     _short_opts: list[str]
     action: str
     dest: str | None
-    default: Any
+    default: Incomplete
     nargs: int
-    type: Any
-    callback: Callable[..., Any] | None
-    callback_args: tuple[Any, ...] | None
-    callback_kwargs: dict[str, Any] | None
+    type: Incomplete
+    callback: Callable[..., Incomplete] | None
+    callback_args: tuple[Incomplete, ...] | None
+    callback_kwargs: dict[str, Incomplete] | None
     help: str | None
     metavar: str | None
-    def __init__(self, *opts: str | None, **attrs: Any) -> None: ...
+    def __init__(self, *opts: str | None, **attrs) -> None: ...
     def _check_action(self) -> None: ...
     def _check_callback(self) -> None: ...
     def _check_choice(self) -> None: ...
@@ -125,13 +126,13 @@ class Option:
     def _check_nargs(self) -> None: ...
     def _check_opt_strings(self, opts: Iterable[str | None]) -> list[str]: ...
     def _check_type(self) -> None: ...
-    def _set_attrs(self, attrs: dict[str, Any]) -> None: ...
+    def _set_attrs(self, attrs: dict[str, Incomplete]) -> None: ...
     def _set_opt_strings(self, opts: Iterable[str]) -> None: ...
-    def check_value(self, opt: str, value: Any) -> Any: ...
-    def convert_value(self, opt: str, value: Any) -> Any: ...
+    def check_value(self, opt: str, value): ...
+    def convert_value(self, opt: str, value): ...
     def get_opt_string(self) -> str: ...
-    def process(self, opt: Any, value: Any, values: Any, parser: OptionParser) -> int: ...
-    def take_action(self, action: str, dest: str, opt: Any, value: Any, values: Any, parser: OptionParser) -> int: ...
+    def process(self, opt, value, values, parser: OptionParser) -> int: ...
+    def take_action(self, action: str, dest: str, opt, value, values, parser: OptionParser) -> int: ...
     def takes_value(self) -> bool: ...
 
 make_option = Option
@@ -140,28 +141,30 @@ class OptionContainer:
     _long_opt: dict[str, Option]
     _short_opt: dict[str, Option]
     conflict_handler: str
-    defaults: dict[str, Any]
-    description: Any
+    defaults: dict[str, Incomplete]
+    description: str | None
     option_class: type[Option]
-    def __init__(self, option_class: type[Option], conflict_handler: Any, description: Any) -> None: ...
-    def _check_conflict(self, option: Any) -> None: ...
+    def __init__(
+        self, option_class: type[Option], conflict_handler: Literal["error", "resolve"], description: str | None
+    ) -> None: ...
+    def _check_conflict(self, option: Option) -> None: ...
     def _create_option_mappings(self) -> None: ...
     def _share_option_mappings(self, parser: OptionParser) -> None: ...
     @overload
     def add_option(self, opt: Option) -> Option: ...
     @overload
-    def add_option(self, *args: str | None, **kwargs: Any) -> Any: ...
+    def add_option(self, arg: str, /, *args: str | None, **kwargs) -> Option: ...
     def add_options(self, option_list: Iterable[Option]) -> None: ...
     def destroy(self) -> None: ...
-    def format_description(self, formatter: HelpFormatter | None) -> Any: ...
-    def format_help(self, formatter: HelpFormatter | None) -> str: ...
-    def format_option_help(self, formatter: HelpFormatter | None) -> str: ...
-    def get_description(self) -> Any: ...
+    def format_option_help(self, formatter: HelpFormatter) -> str: ...
+    def format_description(self, formatter: HelpFormatter) -> str: ...
+    def format_help(self, formatter: HelpFormatter) -> str: ...
+    def get_description(self) -> str | None: ...
     def get_option(self, opt_str: str) -> Option | None: ...
     def has_option(self, opt_str: str) -> bool: ...
     def remove_option(self, opt_str: str) -> None: ...
-    def set_conflict_handler(self, handler: Any) -> None: ...
-    def set_description(self, description: Any) -> None: ...
+    def set_conflict_handler(self, handler: Literal["error", "resolve"]) -> None: ...
+    def set_description(self, description: str | None) -> None: ...
 
 class OptionGroup(OptionContainer):
     option_list: list[Option]
@@ -172,15 +175,15 @@ class OptionGroup(OptionContainer):
     def set_title(self, title: str) -> None: ...
 
 class Values:
-    def __init__(self, defaults: Mapping[str, Any] | None = None) -> None: ...
-    def _update(self, dict: Mapping[str, Any], mode: Any) -> None: ...
-    def _update_careful(self, dict: Mapping[str, Any]) -> None: ...
-    def _update_loose(self, dict: Mapping[str, Any]) -> None: ...
-    def ensure_value(self, attr: str, value: Any) -> Any: ...
+    def __init__(self, defaults: Mapping[str, Incomplete] | None = None) -> None: ...
+    def _update(self, dict: Mapping[str, Incomplete], mode) -> None: ...
+    def _update_careful(self, dict: Mapping[str, Incomplete]) -> None: ...
+    def _update_loose(self, dict: Mapping[str, Incomplete]) -> None: ...
+    def ensure_value(self, attr: str, value): ...
     def read_file(self, filename: str, mode: str = "careful") -> None: ...
     def read_module(self, modname: str, mode: str = "careful") -> None: ...
-    def __getattr__(self, name: str) -> Any: ...
-    def __setattr__(self, name: str, value: Any, /) -> None: ...
+    def __getattr__(self, name: str): ...
+    def __setattr__(self, name: str, value, /) -> None: ...
     def __eq__(self, other: object) -> bool: ...
 
 class OptionParser(OptionContainer):
@@ -190,9 +193,9 @@ class OptionParser(OptionContainer):
     largs: list[str] | None
     option_groups: list[OptionGroup]
     option_list: list[Option]
-    process_default_values: Any
+    process_default_values: bool
     prog: str | None
-    rargs: list[Any] | None
+    rargs: list[str] | None
     standard_option_list: list[Option]
     usage: str | None
     values: Values | None
@@ -214,28 +217,28 @@ class OptionParser(OptionContainer):
     def _add_version_option(self) -> None: ...
     def _create_option_list(self) -> None: ...
     def _get_all_options(self) -> list[Option]: ...
-    def _get_args(self, args: Iterable[Any]) -> list[Any]: ...
+    def _get_args(self, args: Iterable[Incomplete]) -> list[Incomplete]: ...
     def _init_parsing_state(self) -> None: ...
     def _match_long_opt(self, opt: str) -> str: ...
     def _populate_option_list(self, option_list: Iterable[Option], add_help: bool = True) -> None: ...
-    def _process_args(self, largs: list[Any], rargs: list[Any], values: Values) -> None: ...
-    def _process_long_opt(self, rargs: list[Any], values: Any) -> None: ...
-    def _process_short_opts(self, rargs: list[Any], values: Any) -> None: ...
+    def _process_args(self, largs: list[Incomplete], rargs: list[Incomplete], values: Values) -> None: ...
+    def _process_long_opt(self, rargs: list[Incomplete], values) -> None: ...
+    def _process_short_opts(self, rargs: list[Incomplete], values) -> None: ...
     @overload
     def add_option_group(self, opt_group: OptionGroup, /) -> OptionGroup: ...
     @overload
-    def add_option_group(self, *args: Any, **kwargs: Any) -> OptionGroup: ...
+    def add_option_group(self, *args, **kwargs) -> OptionGroup: ...
     def check_values(self, values: Values, args: list[str]) -> tuple[Values, list[str]]: ...
     def disable_interspersed_args(self) -> None: ...
     def enable_interspersed_args(self) -> None: ...
     def error(self, msg: str) -> None: ...
     def exit(self, status: int = 0, msg: str | None = None) -> None: ...
-    def expand_prog_name(self, s: str | None) -> Any: ...
-    def format_epilog(self, formatter: HelpFormatter) -> Any: ...
+    def expand_prog_name(self, s: str) -> str: ...
+    def format_epilog(self, formatter: HelpFormatter) -> str: ...
     def format_help(self, formatter: HelpFormatter | None = None) -> str: ...
     def format_option_help(self, formatter: HelpFormatter | None = None) -> str: ...
     def get_default_values(self) -> Values: ...
-    def get_option_group(self, opt_str: str) -> Any: ...
+    def get_option_group(self, opt_str: str) -> OptionGroup | None: ...
     def get_prog_name(self) -> str: ...
     def get_usage(self) -> str: ...
     def get_version(self) -> str: ...
@@ -246,7 +249,7 @@ class OptionParser(OptionContainer):
     def print_usage(self, file: IO[str] | None = None) -> None: ...
     def print_help(self, file: IO[str] | None = None) -> None: ...
     def print_version(self, file: IO[str] | None = None) -> None: ...
-    def set_default(self, dest: Any, value: Any) -> None: ...
-    def set_defaults(self, **kwargs: Any) -> None: ...
-    def set_process_default_values(self, process: Any) -> None: ...
+    def set_default(self, dest, value) -> None: ...
+    def set_defaults(self, **kwargs) -> None: ...
+    def set_process_default_values(self, process) -> None: ...
     def set_usage(self, usage: str) -> None: ...

package/dist/typeshed-fallback/stdlib/pyexpat/__init__.pyi

@@ -32,6 +32,8 @@ class XMLParserType:
     def ExternalEntityParserCreate(self, context: str | None, encoding: str = ..., /) -> XMLParserType: ...
     def SetParamEntityParsing(self, flag: int, /) -> int: ...
     def UseForeignDTD(self, flag: bool = True, /) -> None: ...
+    def GetReparseDeferralEnabled(self) -> bool: ...
+    def SetReparseDeferralEnabled(self, enabled: bool, /) -> None: ...
     @property
     def intern(self) -> dict[str, str]: ...
     buffer_size: int

package/dist/typeshed-fallback/stdlib/xml/etree/ElementTree.pyi

@@ -250,6 +250,7 @@ class XMLPullParser:
     # Second element in the tuple could be `Element`, `tuple[str, str]` or `None`.
     # Use `Any` to avoid false-positive errors.
     def read_events(self) -> Iterator[tuple[str, Any]]: ...
+    def flush(self) -> None: ...
 
 def XML(text: str | ReadableBuffer, parser: XMLParser | None = None) -> Element: ...
 def XMLID(text: str | ReadableBuffer, parser: XMLParser | None = None) -> tuple[Element, dict[str, Element]]: ...
@@ -323,3 +324,4 @@ class XMLParser:
     def __init__(self, *, target: Any = ..., encoding: str | None = ...) -> None: ...
     def close(self) -> Any: ...
     def feed(self, data: str | ReadableBuffer, /) -> None: ...
+    def flush(self) -> None: ...

package/dist/typeshed-fallback/stubs/Pillow/PIL/ImageSequence.pyi

@@ -1,11 +1,14 @@
-from _typeshed import Incomplete
+from collections.abc import Callable
+from typing_extensions import Self
+
+from .Image import Image
 
 class Iterator:
-    im: Incomplete
-    position: Incomplete
-    def __init__(self, im) -> None: ...
-    def __getitem__(self, ix): ...
-    def __iter__(self): ...
-    def __next__(self): ...
+    im: Image
+    position: int
+    def __init__(self, im: Image) -> None: ...
+    def __getitem__(self, ix: int) -> Image: ...
+    def __iter__(self) -> Self: ...
+    def __next__(self) -> Image: ...
 
-def all_frames(im, func: Incomplete | None = None): ...
+def all_frames(im: Image | list[Image], func: Callable[[Image], Image] | None = None) -> list[Image]: ...

package/dist/typeshed-fallback/stubs/croniter/croniter/croniter.pyi

@@ -36,7 +36,7 @@ class CroniterNotAlphaError(CroniterError): ...
 def datetime_to_timestamp(d: datetime.datetime) -> float: ...
 
 class croniter(Iterator[Any]):
-    MONTHS_IN_YEAR: Final[Literal[12]]
+    MONTHS_IN_YEAR: Final = 12
     RANGES: Final[tuple[tuple[int, int], tuple[int, int], tuple[int, int], tuple[int, int], tuple[int, int], tuple[int, int]]]
     DAYS: Final[
         tuple[
@@ -106,6 +106,10 @@ class croniter(Iterator[Any]):
     def is_valid(cls, expression: str, hash_id: bytes | None = None) -> bool: ...
     @classmethod
     def match(cls, cron_expression: str, testdate: float | datetime.datetime | None, day_or: bool = True) -> bool: ...
+    @classmethod
+    def match_range(
+        cls, cron_expression: str, from_datetime: datetime.datetime, to_datetime: datetime.datetime, day_or: bool = True
+    ) -> bool: ...
 
 def croniter_range(
     start: float | datetime.datetime,

package/dist/typeshed-fallback/stubs/docutils/docutils/nodes.pyi

@@ -104,15 +104,25 @@ class Text(Node, str):
     def rstrip(self, chars: str | None = None) -> str: ...
     def lstrip(self, chars: str | None = None) -> str: ...
 
+_T = TypeVar("_T")
+
 class Element(Node):
+    local_attributes: ClassVar[Sequence[str]]
+    basic_attributes: ClassVar[Sequence[str]]
+    list_attributes: ClassVar[Sequence[str]]
+    known_attributes: ClassVar[Sequence[str]]
+    tagname: str
+    child_text_separator: ClassVar[str]
+    attributes: dict[str, Any]
     children: list[Node]
     rawsource: str
-    def __init__(self, rawsource: str = "", *children: Node, **attributes): ...
+    def __init__(self, rawsource: str = "", *children: Node, **attributes: Any) -> None: ...
+    def shortrepr(self) -> str: ...
+    def starttag(self, quoteattr: Callable[[str], str] | None = None) -> str: ...
+    def endtag(self) -> str: ...
+    def emptytag(self) -> str: ...
     def __len__(self) -> int: ...
     def __contains__(self, key: str | Node) -> bool: ...
-    # '__iter__' is added as workaround, since mypy doesn't support classes that are iterable via '__getitem__'
-    # see https://github.com/python/typeshed/pull/10099#issuecomment-1528789395
-    def __iter__(self) -> Iterator[Node]: ...
     @overload
     def __getitem__(self, key: str) -> Any: ...
     @overload
@@ -129,19 +139,78 @@ class Element(Node):
     def __add__(self, other: list[Node]) -> list[Node]: ...
     def __radd__(self, other: list[Node]) -> list[Node]: ...
     def __iadd__(self, other: Node | Iterable[Node]) -> Self: ...
-    def copy(self) -> Self: ...
-    def deepcopy(self) -> Self: ...
-    def pformat(self, indent: str = "    ", level: int = 0) -> str: ...
     def astext(self) -> str: ...
-    def index(self, item: Node, start: int = 0, stop: int = sys.maxsize) -> int: ...
-    def remove(self, item: Node) -> None: ...
+    def non_default_attributes(self) -> dict[str, Any]: ...
+    def attlist(self) -> list[tuple[str, Any]]: ...
+    @overload
+    def get(self, key: str) -> Any: ...
+    @overload
+    def get(self, key: str, failobj: _T) -> _T: ...
+    def hasattr(self, attr: str) -> bool: ...
+    def delattr(self, attr: str) -> None: ...
+    @overload
+    def setdefault(self, key: str) -> Any: ...
+    @overload
+    def setdefault(self, key: str, failobj: _T) -> Any | _T: ...
+    has_key = hasattr
+    def get_language_code(self, fallback: str = "") -> str: ...
+    def append(self, item: Node) -> None: ...
+    def extend(self, item: Iterable[Node]) -> None: ...
     def insert(self, index: SupportsIndex, item: Node | Iterable[Node] | None) -> None: ...
+    def pop(self, i: int = -1) -> Node: ...
+    def remove(self, item: Node) -> None: ...
+    def index(self, item: Node, start: int = 0, stop: int = sys.maxsize) -> int: ...
     def previous_sibling(self) -> Node | None: ...
-    def __getattr__(self, name: str, /) -> Incomplete: ...
+    def is_not_default(self, key: str) -> bool: ...
+    def update_basic_atts(self, dict_: Mapping[str, Any] | Node) -> None: ...
+    def append_attr_list(self, attr: str, values: Iterable[Any]) -> None: ...
+    def coerce_append_attr_list(self, attr: str, value) -> None: ...
+    def replace_attr(self, attr: str, value: Any, force: bool = True) -> None: ...
+    def copy_attr_convert(self, attr: str, value: Any, replace: bool = True) -> None: ...
+    def copy_attr_coerce(self, attr: str, value: Any, replace: bool) -> None: ...
+    def copy_attr_concatenate(self, attr: str, value: Any, replace: bool) -> None: ...
+    def copy_attr_consistent(self, attr: str, value: Any, replace: bool) -> None: ...
+    def update_all_atts(
+        self,
+        dict_: Mapping[str, Any] | Node,
+        update_fun: Callable[[Element, str, Any, bool], object] = ...,
+        replace: bool = True,
+        and_source: bool = False,
+    ) -> None: ...
+    def update_all_atts_consistantly(
+        self, dict_: Mapping[str, Any] | Node, replace: bool = True, and_source: bool = False
+    ) -> None: ...
+    def update_all_atts_concatenating(
+        self, dict_: dict[str, Any] | Node, replace: bool = True, and_source: bool = False
+    ) -> None: ...
+    def update_all_atts_coercion(
+        self, dict_: Mapping[str, Any] | Node, replace: bool = True, and_source: bool = False
+    ) -> None: ...
+    def update_all_atts_convert(self, dict_: Mapping[str, Any] | Node, and_source: bool = False) -> None: ...
+    def clear(self) -> None: ...
+    def replace(self, old: Node, new: Node | Sequence[Node]) -> None: ...
+    def replace_self(self, new: Node | Sequence[Node]) -> None: ...
+    def first_child_matching_class(
+        self, childclass: type[Node] | tuple[type[Node], ...], start: int = 0, end: int = sys.maxsize
+    ) -> int | None: ...
+    def first_child_not_matching_class(
+        self, childclass: type[Node] | tuple[type[Node], ...], start: int = 0, end: int = sys.maxsize
+    ) -> int | None: ...
+    def pformat(self, indent: str = "    ", level: int = 0) -> str: ...
+    def copy(self) -> Self: ...
+    def deepcopy(self) -> Self: ...
+    def set_class(self, name: str) -> None: ...
+    def note_referenced_by(self, name: str | None = None, id: str | None = None) -> None: ...
+    @classmethod
+    def is_not_list_attribute(cls, attr: str) -> bool: ...
+    @classmethod
+    def is_not_known_attribute(cls, attr: str) -> bool: ...
+
+    # '__iter__' is added as workaround, since mypy doesn't support classes that are iterable via '__getitem__'
+    # see https://github.com/python/typeshed/pull/10099#issuecomment-1528789395
+    def __iter__(self) -> Iterator[Node]: ...
 
 class TextElement(Element):
-    # A few classes not subclassing TextElement have this, too
-    child_text_separator: ClassVar[str]
     def __init__(self, rawsource: str = "", text: str = "", *children: Node, **attributes) -> None: ...
 
 class FixedTextElement(TextElement): ...
@@ -299,22 +368,11 @@ class field_list(Sequential, Element): ...
 class field(Part, Element): ...
 class field_name(Part, TextElement): ...
 class field_body(Part, Element): ...
-
-# child_text_separator in some option* classes mirrors TextElement,
-# but these classes do not subclass TextElement
-class option(Part, Element):
-    child_text_separator: str
-
+class option(Part, Element): ...
 class option_argument(Part, TextElement): ...
-
-class option_group(Part, Element):
-    child_text_separator: str  # see above
-
+class option_group(Part, Element): ...
 class option_list(Sequential, Element): ...
-
-class option_list_item(Part, Element):
-    child_text_separator: str  # see above
-
+class option_list_item(Part, Element): ...
 class option_string(Part, TextElement): ...
 class description(Part, Element): ...
 class literal_block(General, FixedTextElement): ...

package/dist/typeshed-fallback/stubs/gdb/gdb/__init__.pyi

@@ -5,7 +5,7 @@
 import _typeshed
 from collections.abc import Callable, Iterator, Sequence
 from contextlib import AbstractContextManager
-from typing import Protocol, final, overload
+from typing import Literal, Protocol, final, overload
 from typing_extensions import TypeAlias
 
 import gdb.types
@@ -23,7 +23,14 @@ STDOUT: int
 STDERR: int
 STDLOG: int
 
-def execute(command: str, from_tty: bool = ..., to_string: bool = ...) -> str | None: ...
+@overload
+def execute(command: str, from_tty: bool = False, to_string: Literal[False] = False) -> None: ...
+@overload
+def execute(command: str, *, to_string: Literal[True]) -> str: ...
+@overload
+def execute(command: str, from_tty: bool, to_string: Literal[True]) -> str: ...
+@overload
+def execute(command: str, from_tty: bool = False, to_string: bool = False) -> str | None: ...
 def breakpoints() -> Sequence[Breakpoint]: ...
 def rbreak(regex: str, minsyms: bool = ..., throttle: int = ..., symtabs: Iterator[Symtab] = ...) -> list[Breakpoint]: ...
 def parameter(parameter: str, /) -> bool | int | str | None: ...

package/dist/typeshed-fallback/stubs/hdbcli/METADATA.toml

@@ -1,2 +1,2 @@
-version = "2.19.*"
+version = "2.20.*"
 # upstream_repository = closed-source

package/dist/typeshed-fallback/stubs/hvac/METADATA.toml

@@ -0,0 +1,2 @@
+version = "2.1.*"
+upstream_repository = "https://github.com/hvac/hvac"

package/dist/typeshed-fallback/stubs/hvac/hvac/__init__.pyi

@@ -0,0 +1,3 @@
+from hvac.v1 import Client as Client
+
+__all__ = ("Client",)