basedpyright 1.25.0 → 1.26.0

package/dist/typeshed-fallback/stdlib/multiprocessing/managers.pyi

@@ -1,13 +1,14 @@
 import queue
 import sys
 import threading
-from _typeshed import Incomplete, SupportsKeysAndGetItem, SupportsRichComparison, SupportsRichComparisonT
+from _typeshed import SupportsKeysAndGetItem, SupportsRichComparison, SupportsRichComparisonT
 from collections.abc import Callable, Iterable, Iterator, Mapping, MutableMapping, MutableSequence, Sequence
 from types import TracebackType
 from typing import Any, AnyStr, ClassVar, Generic, SupportsIndex, TypeVar, overload
 from typing_extensions import Self, TypeAlias
 
-from .connection import Connection
+from . import pool
+from .connection import Connection, _Address
 from .context import BaseContext
 from .shared_memory import _SLT, ShareableList as _ShareableList, SharedMemory as _SharedMemory
 from .util import Finalize as _Finalize
@@ -32,14 +33,14 @@ _Namespace: TypeAlias = Namespace
 
 class Token:
     typeid: str | bytes | None
-    address: tuple[str | bytes, int]
+    address: _Address | None
     id: str | bytes | int | None
-    def __init__(self, typeid: bytes | str | None, address: tuple[str | bytes, int], id: str | bytes | int | None) -> None: ...
+    def __init__(self, typeid: bytes | str | None, address: _Address | None, id: str | bytes | int | None) -> None: ...
     def __getstate__(self) -> tuple[str | bytes | None, tuple[str | bytes, int], str | bytes | int | None]: ...
     def __setstate__(self, state: tuple[str | bytes | None, tuple[str | bytes, int], str | bytes | int | None]) -> None: ...
 
 class BaseProxy:
-    _address_to_local: dict[Any, Any]
+    _address_to_local: dict[_Address, Any]
     _mutex: Any
     def __init__(
         self,
@@ -143,6 +144,7 @@ class BaseListProxy(BaseProxy, MutableSequence[_T]):
     def __setitem__(self, s: slice, o: Iterable[_T], /) -> None: ...
     def __mul__(self, n: SupportsIndex, /) -> list[_T]: ...
     def __rmul__(self, n: SupportsIndex, /) -> list[_T]: ...
+    def __imul__(self, value: SupportsIndex, /) -> Self: ...
     def __reversed__(self) -> Iterator[_T]: ...
     def append(self, object: _T, /) -> None: ...
     def extend(self, iterable: Iterable[_T], /) -> None: ...
@@ -170,22 +172,50 @@ class ListProxy(BaseListProxy[_T]):
             """
             ...
 
+# Send is (kind, result)
+# Receive is (id, methodname, args, kwds)
+_ServerConnection: TypeAlias = Connection[tuple[str, Any], tuple[str, str, Iterable[Any], Mapping[str, Any]]]
+
 # Returned by BaseManager.get_server()
 class Server:
-    address: Any
+    address: _Address | None
+    id_to_obj: dict[str, tuple[Any, set[str], dict[str, str]]]
+    fallback_mapping: dict[str, Callable[[_ServerConnection, str, Any], Any]]
+    public: list[str]
+    # Registry values are (callable, exposed, method_to_typeid, proxytype)
     def __init__(
-        self, registry: dict[str, tuple[Callable[..., Any], Any, Any, Any]], address: Any, authkey: bytes, serializer: str
+        self,
+        registry: dict[str, tuple[Callable[..., Any], Iterable[str], dict[str, str], Any]],
+        address: _Address | None,
+        authkey: bytes,
+        serializer: str,
     ) -> None: ...
     def serve_forever(self) -> None: ...
-    def accept_connection(
-        self, c: Connection[tuple[str, str | None], tuple[str, str, Iterable[Incomplete], Mapping[str, Incomplete]]], name: str
-    ) -> None: ...
+    def accepter(self) -> None: ...
+    if sys.version_info >= (3, 10):
+        def handle_request(self, conn: _ServerConnection) -> None: ...
+    else:
+        def handle_request(self, c: _ServerConnection) -> None: ...
+
+    def serve_client(self, conn: _ServerConnection) -> None: ...
+    def fallback_getvalue(self, conn: _ServerConnection, ident: str, obj: _T) -> _T: ...
+    def fallback_str(self, conn: _ServerConnection, ident: str, obj: Any) -> str: ...
+    def fallback_repr(self, conn: _ServerConnection, ident: str, obj: Any) -> str: ...
+    def dummy(self, c: _ServerConnection) -> None: ...
+    def debug_info(self, c: _ServerConnection) -> str: ...
+    def number_of_objects(self, c: _ServerConnection) -> int: ...
+    def shutdown(self, c: _ServerConnection) -> None: ...
+    def create(self, c: _ServerConnection, typeid: str, /, *args: Any, **kwds: Any) -> tuple[str, tuple[str, ...]]: ...
+    def get_methods(self, c: _ServerConnection, token: Token) -> set[str]: ...
+    def accept_connection(self, c: _ServerConnection, name: str) -> None: ...
+    def incref(self, c: _ServerConnection, ident: str) -> None: ...
+    def decref(self, c: _ServerConnection, ident: str) -> None: ...
 
 class BaseManager:
     if sys.version_info >= (3, 11):
         def __init__(
             self,
-            address: Any | None = None,
+            address: _Address | None = None,
             authkey: bytes | None = None,
             serializer: str = "pickle",
             ctx: BaseContext | None = None,
@@ -195,7 +225,7 @@ class BaseManager:
     else:
         def __init__(
             self,
-            address: Any | None = None,
+            address: _Address | None = None,
             authkey: bytes | None = None,
             serializer: str = "pickle",
             ctx: BaseContext | None = None,
@@ -207,7 +237,7 @@ class BaseManager:
     shutdown: _Finalize  # only available after start() was called
     def join(self, timeout: float | None = None) -> None: ...  # undocumented
     @property
-    def address(self) -> Any: ...
+    def address(self) -> _Address | None: ...
     @classmethod
     def register(
         cls,
@@ -224,14 +254,26 @@ class BaseManager:
     ) -> None: ...
 
 class SyncManager(BaseManager):
-    def BoundedSemaphore(self, value: Any = ...) -> threading.BoundedSemaphore: ...
-    def Condition(self, lock: Any = ...) -> threading.Condition: ...
+    def Barrier(
+        self, parties: int, action: Callable[[], None] | None = None, timeout: float | None = None
+    ) -> threading.Barrier: ...
+    def BoundedSemaphore(self, value: int = 1) -> threading.BoundedSemaphore: ...
+    def Condition(self, lock: threading.Lock | threading._RLock | None = None) -> threading.Condition: ...
     def Event(self) -> threading.Event: ...
     def Lock(self) -> threading.Lock: ...
     def Namespace(self) -> _Namespace: ...
+    def Pool(
+        self,
+        processes: int | None = None,
+        initializer: Callable[..., object] | None = None,
+        initargs: Iterable[Any] = (),
+        maxtasksperchild: int | None = None,
+        context: Any | None = None,
+    ) -> pool.Pool: ...
     def Queue(self, maxsize: int = ...) -> queue.Queue[Any]: ...
+    def JoinableQueue(self, maxsize: int = ...) -> queue.Queue[Any]: ...
     def RLock(self) -> threading.RLock: ...
-    def Semaphore(self, value: Any = ...) -> threading.Semaphore: ...
+    def Semaphore(self, value: int = 1) -> threading.Semaphore: ...
     def Array(self, typecode: Any, sequence: Sequence[_T]) -> Sequence[_T]: ...
     def Value(self, typecode: Any, value: _T) -> ValueProxy[_T]: ...
     # Overloads are copied from builtins.dict.__init__
@@ -257,7 +299,11 @@ class SyncManager(BaseManager):
     def list(self) -> ListProxy[Any]: ...
 
 class RemoteError(Exception): ...
-class SharedMemoryServer(Server): ...
+
+class SharedMemoryServer(Server):
+    def track_segment(self, c: _ServerConnection, segment_name: str) -> None: ...
+    def release_segment(self, c: _ServerConnection, segment_name: str) -> None: ...
+    def list_segments(self, c: _ServerConnection) -> list[str]: ...
 
 class SharedMemoryManager(BaseManager):
     def get_server(self) -> SharedMemoryServer: ...

package/dist/typeshed-fallback/stdlib/multiprocessing/pool.pyi

@@ -1,5 +1,6 @@
 import sys
 from collections.abc import Callable, Iterable, Mapping
+from multiprocessing.context import DefaultContext, Process
 from types import TracebackType
 from typing import Any, Final, Generic, TypeVar
 from typing_extensions import Self
@@ -59,6 +60,8 @@ class Pool:
         maxtasksperchild: int | None = None,
         context: Any | None = None,
     ) -> None: ...
+    @staticmethod
+    def Process(ctx: DefaultContext, *args: Any, **kwds: Any) -> Process: ...
     def apply(self, func: Callable[..., _T], args: Iterable[Any] = (), kwds: Mapping[str, Any] = {}) -> _T: ...
     def apply_async(
         self,

package/dist/typeshed-fallback/stdlib/multiprocessing/reduction.pyi

@@ -1,12 +1,12 @@
 import pickle
 import sys
+from _pickle import _ReducedType
 from _typeshed import HasFileno, SupportsWrite, Unused
 from abc import ABCMeta
 from builtins import type as Type  # alias to avoid name clash
 from collections.abc import Callable
 from copyreg import _DispatchTableType
 from multiprocessing import connection
-from pickle import _ReducedType
 from socket import socket
 from typing import Any, Final
 

package/dist/typeshed-fallback/stdlib/multiprocessing/synchronize.pyi

@@ -54,6 +54,7 @@ class RLock(SemLock):
 
 class Semaphore(SemLock):
     def __init__(self, value: int = 1, *, ctx: BaseContext) -> None: ...
+    def get_value(self) -> int: ...
 
 class BoundedSemaphore(Semaphore):
     def __init__(self, value: int = 1, *, ctx: BaseContext) -> None: ...

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

@@ -9,7 +9,7 @@
 
 from _typeshed import Incomplete
 from abc import ABCMeta, abstractmethod
-from typing import Literal, Protocol, overload
+from typing import ClassVar, Literal, Protocol, overload
 
 __all__ = ["Number", "Complex", "Real", "Rational", "Integral"]
 
@@ -114,6 +114,7 @@ class Complex(Number, _ComplexLike):
     def conjugate(self) -> _ComplexLike: ...
     @abstractmethod
     def __eq__(self, other: object) -> bool: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
 
 # See comment at the top of the file
 # for why some of these return types are purposefully vague

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

@@ -54,7 +54,7 @@ from _operator import (
 )
 from _typeshed import SupportsGetItem
 from typing import Any, Generic, TypeVar, final, overload
-from typing_extensions import TypeVarTuple, Unpack
+from typing_extensions import Self, TypeVarTuple, Unpack
 
 _T = TypeVar("_T")
 _T_co = TypeVar("_T_co", covariant=True)
@@ -215,7 +215,7 @@ class itemgetter(Generic[_T_co]):
 
 @final
 class methodcaller:
-    def __init__(self, name: str, /, *args: Any, **kwargs: Any) -> None: ...
+    def __new__(cls, name: str, /, *args: Any, **kwargs: Any) -> Self: ...
     def __call__(self, obj: Any) -> Any:
         """Call self as a function."""
         ...

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

@@ -1,7 +1,9 @@
+import builtins
 from _typeshed import Incomplete, MaybeNone
 from abc import abstractmethod
 from collections.abc import Callable, Iterable, Mapping, Sequence
-from typing import IO, Any, AnyStr, Literal, NoReturn, overload
+from typing import IO, Any, AnyStr, ClassVar, Literal, NoReturn, overload
+from typing_extensions import Self
 
 __all__ = [
     "Option",
@@ -27,8 +29,9 @@ NO_DEFAULT: tuple[str, ...]
 SUPPRESS_HELP: str
 SUPPRESS_USAGE: str
 
-def check_builtin(option: Option, opt, value: str): ...
-def check_choice(option: Option, opt, value: str) -> str: ...
+# Can return complex, float, or int depending on the option's type
+def check_builtin(option: Option, opt: str, value: str) -> complex: ...
+def check_choice(option: Option, opt: str, value: str) -> str: ...
 
 class OptParseError(Exception):
     msg: str
@@ -62,9 +65,11 @@ class HelpFormatter:
     max_help_position: int
     option_strings: dict[Option, str]
     parser: OptionParser
-    short_first: Incomplete
+    short_first: bool | Literal[0, 1]
     width: int
-    def __init__(self, indent_increment: int, max_help_position: int, width: int | None, short_first: int) -> None: ...
+    def __init__(
+        self, indent_increment: int, max_help_position: int, width: int | None, short_first: bool | Literal[0, 1]
+    ) -> None: ...
     def dedent(self) -> None: ...
     def expand_default(self, option: Option) -> str: ...
     def format_description(self, description: str | None) -> str: ...
@@ -83,14 +88,22 @@ class HelpFormatter:
 
 class IndentedHelpFormatter(HelpFormatter):
     def __init__(
-        self, indent_increment: int = 2, max_help_position: int = 24, width: int | None = None, short_first: int = 1
+        self,
+        indent_increment: int = 2,
+        max_help_position: int = 24,
+        width: int | None = None,
+        short_first: bool | Literal[0, 1] = 1,
     ) -> None: ...
     def format_heading(self, heading: str) -> str: ...
     def format_usage(self, usage: str) -> str: ...
 
 class TitledHelpFormatter(HelpFormatter):
     def __init__(
-        self, indent_increment: int = 0, max_help_position: int = 24, width: int | None = None, short_first: int = 0
+        self,
+        indent_increment: int = 0,
+        max_help_position: int = 24,
+        width: int | None = None,
+        short_first: bool | Literal[0, 1] = 0,
     ) -> None: ...
     def format_heading(self, heading: str) -> str: ...
     def format_usage(self, usage: str) -> str: ...
@@ -99,25 +112,46 @@ class Option:
     ACTIONS: tuple[str, ...]
     ALWAYS_TYPED_ACTIONS: tuple[str, ...]
     ATTRS: list[str]
-    CHECK_METHODS: list[Callable[..., Incomplete]] | None
+    CHECK_METHODS: list[Callable[[Self], object]] | None
     CONST_ACTIONS: tuple[str, ...]
     STORE_ACTIONS: tuple[str, ...]
     TYPED_ACTIONS: tuple[str, ...]
     TYPES: tuple[str, ...]
-    TYPE_CHECKER: dict[str, Callable[[Option, str, Incomplete], Any]]
+    TYPE_CHECKER: dict[str, Callable[[Option, str, str], object]]
     _long_opts: list[str]
     _short_opts: list[str]
     action: str
+    type: str | None
     dest: str | None
-    default: Incomplete
+    default: Any  # default can be "any" type
     nargs: int
-    type: Incomplete
-    callback: Callable[..., Incomplete] | None
-    callback_args: tuple[Incomplete, ...] | None
-    callback_kwargs: dict[str, Incomplete] | None
+    const: Any | None  # const can be "any" type
+    choices: list[str] | tuple[str, ...] | None
+    # Callback args and kwargs cannot be expressed in Python's type system.
+    # Revisit if ParamSpec is ever changed to work with packed args/kwargs.
+    callback: Callable[..., object] | None
+    callback_args: tuple[Any, ...] | None
+    callback_kwargs: dict[str, Any] | None
     help: str | None
     metavar: str | None
-    def __init__(self, *opts: str | None, **attrs) -> None: ...
+    def __init__(
+        self,
+        *opts: str | None,
+        # The following keywords are handled by the _set_attrs method. All default to
+        # `None` except for `default`, which defaults to `NO_DEFAULT`.
+        action: str | None = None,
+        type: str | builtins.type | None = None,
+        dest: str | None = None,
+        default: Any = ...,  # = NO_DEFAULT
+        nargs: int | None = None,
+        const: Any | None = None,
+        choices: list[str] | tuple[str, ...] | None = None,
+        callback: Callable[..., object] | None = None,
+        callback_args: tuple[Any, ...] | None = None,
+        callback_kwargs: dict[str, Any] | None = None,
+        help: str | None = None,
+        metavar: str | None = None,
+    ) -> None: ...
     def _check_action(self) -> None: ...
     def _check_callback(self) -> None: ...
     def _check_choice(self) -> None: ...
@@ -126,13 +160,14 @@ 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, Incomplete]) -> None: ...
+    def _set_attrs(self, attrs: dict[str, Any]) -> None: ...  # accepted attrs depend on the ATTRS attribute
     def _set_opt_strings(self, opts: Iterable[str]) -> None: ...
-    def check_value(self, opt: str, value): ...
-    def convert_value(self, opt: str, value): ...
+    def check_value(self, opt: str, value: str) -> Any: ...  # return type cannot be known statically
+    def convert_value(self, opt: str, value: str | tuple[str, ...] | None) -> Any: ...  # return type cannot be known statically
     def get_opt_string(self) -> str: ...
-    def process(self, opt, value, values, parser: OptionParser) -> int: ...
-    def take_action(self, action: str, dest: str, opt, value, values, parser: OptionParser) -> int: ...
+    def process(self, opt: str, value: str | tuple[str, ...] | None, values: Values, parser: OptionParser) -> int: ...
+    # value of take_action can be "any" type
+    def take_action(self, action: str, dest: str, opt: str, value: Any, values: Values, parser: OptionParser) -> int: ...
     def takes_value(self) -> bool: ...
 
 make_option = Option
@@ -141,7 +176,7 @@ class OptionContainer:
     _long_opt: dict[str, Option]
     _short_opt: dict[str, Option]
     conflict_handler: str
-    defaults: dict[str, Incomplete]
+    defaults: dict[str, Any]  # default values can be "any" type
     description: str | None
     option_class: type[Option]
     def __init__(
@@ -153,7 +188,25 @@ class OptionContainer:
     @overload
     def add_option(self, opt: Option, /) -> Option: ...
     @overload
-    def add_option(self, arg: str, /, *args: str | None, **kwargs) -> Option: ...
+    def add_option(
+        self,
+        opt_str: str,
+        /,
+        *opts: str | None,
+        action: str | None = None,
+        type: str | builtins.type | None = None,
+        dest: str | None = None,
+        default: Any = ...,  # = NO_DEFAULT
+        nargs: int | None = None,
+        const: Any | None = None,
+        choices: list[str] | tuple[str, ...] | None = None,
+        callback: Callable[..., object] | None = None,
+        callback_args: tuple[Any, ...] | None = None,
+        callback_kwargs: dict[str, Any] | None = None,
+        help: str | None = None,
+        metavar: str | None = None,
+        **kwargs,  # Allow arbitrary keyword arguments for user defined option_class
+    ) -> Option: ...
     def add_options(self, option_list: Iterable[Option]) -> None: ...
     def destroy(self) -> None: ...
     def format_option_help(self, formatter: HelpFormatter) -> str: ...
@@ -175,15 +228,19 @@ class OptionGroup(OptionContainer):
     def set_title(self, title: str) -> None: ...
 
 class Values:
-    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): ...
-    def __setattr__(self, name: str, value, /) -> None:
+    def __init__(self, defaults: Mapping[str, object] | None = None) -> None: ...
+    def _update(self, dict: Mapping[str, object], mode: Literal["careful", "loose"]) -> None: ...
+    def _update_careful(self, dict: Mapping[str, object]) -> None: ...
+    def _update_loose(self, dict: Mapping[str, object]) -> None: ...
+    def ensure_value(self, attr: str, value: object) -> Any: ...  # return type cannot be known statically
+    def read_file(self, filename: str, mode: Literal["careful", "loose"] = "careful") -> None: ...
+    def read_module(self, modname: str, mode: Literal["careful", "loose"] = "careful") -> None: ...
+    __hash__: ClassVar[None]  # type: ignore[assignment]
+    # __getattr__ doesn't exist, but anything passed as a default to __init__
+    # is set on the instance.
+    def __getattr__(self, name: str) -> Any: ...
+    # TODO mypy infers -> object for __getattr__ if __setattr__ has `value: object`
+    def __setattr__(self, name: str, value: Any, /) -> None:
         """Implement setattr(self, name, value)."""
         ...
     def __eq__(self, other: object) -> bool: ...
@@ -229,7 +286,7 @@ class OptionParser(OptionContainer):
     @overload
     def add_option_group(self, opt_group: OptionGroup, /) -> OptionGroup: ...
     @overload
-    def add_option_group(self, *args, **kwargs) -> OptionGroup: ...
+    def add_option_group(self, title: str, /, description: str | None = None) -> 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: ...

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

@@ -231,6 +231,7 @@ if sys.platform == "linux" and sys.version_info >= (3, 12):
         "CLONE_NEWNET",
         "CLONE_NEWNS",
         "CLONE_NEWPID",
+        "CLONE_NEWTIME",
         "CLONE_NEWUSER",
         "CLONE_NEWUTS",
         "CLONE_SIGHAND",

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

@@ -1,7 +1,7 @@
 from _typeshed import StrOrBytesPath
 from collections.abc import Sequence
 from types import CodeType
-from typing import Any, final
+from typing import Any, ClassVar, final
 
 def expr(source: str) -> STType: ...
 def suite(source: str) -> STType: ...
@@ -17,6 +17,7 @@ class ParserError(Exception): ...
 
 @final
 class STType:
+    __hash__: ClassVar[None]  # type: ignore[assignment]
     def compile(self, filename: StrOrBytesPath = ...) -> CodeType: ...
     def isexpr(self) -> bool: ...
     def issuite(self) -> bool: ...