basedpyright 1.13.2 → 1.13.3

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

@@ -1,45 +1,45 @@
-from _typeshed import SizedBuffer
-from typing import IO, Any, Literal
-from typing_extensions import TypeAlias
-
-__all__ = ["binhex", "hexbin", "Error"]
-
-class Error(Exception): ...
-
-REASONABLY_LARGE: Literal[32768]
-LINELEN: Literal[64]
-RUNCHAR: Literal[b"\x90"]
-
-class FInfo:
-    Type: str
-    Creator: str
-    Flags: int
-
-_FileInfoTuple: TypeAlias = tuple[str, FInfo, int, int]
-_FileHandleUnion: TypeAlias = str | IO[bytes]
-
-def getfileinfo(name: str) -> _FileInfoTuple: ...
-
-class openrsrc:
-    def __init__(self, *args: Any) -> None: ...
-    def read(self, *args: Any) -> bytes: ...
-    def write(self, *args: Any) -> None: ...
-    def close(self) -> None: ...
-
-class BinHex:
-    def __init__(self, name_finfo_dlen_rlen: _FileInfoTuple, ofp: _FileHandleUnion) -> None: ...
-    def write(self, data: SizedBuffer) -> None: ...
-    def close_data(self) -> None: ...
-    def write_rsrc(self, data: SizedBuffer) -> None: ...
-    def close(self) -> None: ...
-
-def binhex(inp: str, out: str) -> None: ...
-
-class HexBin:
-    def __init__(self, ifp: _FileHandleUnion) -> None: ...
-    def read(self, *n: int) -> bytes: ...
-    def close_data(self) -> None: ...
-    def read_rsrc(self, *n: int) -> bytes: ...
-    def close(self) -> None: ...
-
-def hexbin(inp: str, out: str) -> None: ...
+from _typeshed import SizedBuffer
+from typing import IO, Any, Literal
+from typing_extensions import TypeAlias
+
+__all__ = ["binhex", "hexbin", "Error"]
+
+class Error(Exception): ...
+
+REASONABLY_LARGE: Literal[32768]
+LINELEN: Literal[64]
+RUNCHAR: Literal[b"\x90"]
+
+class FInfo:
+    Type: str
+    Creator: str
+    Flags: int
+
+_FileInfoTuple: TypeAlias = tuple[str, FInfo, int, int]
+_FileHandleUnion: TypeAlias = str | IO[bytes]
+
+def getfileinfo(name: str) -> _FileInfoTuple: ...
+
+class openrsrc:
+    def __init__(self, *args: Any) -> None: ...
+    def read(self, *args: Any) -> bytes: ...
+    def write(self, *args: Any) -> None: ...
+    def close(self) -> None: ...
+
+class BinHex:
+    def __init__(self, name_finfo_dlen_rlen: _FileInfoTuple, ofp: _FileHandleUnion) -> None: ...
+    def write(self, data: SizedBuffer) -> None: ...
+    def close_data(self) -> None: ...
+    def write_rsrc(self, data: SizedBuffer) -> None: ...
+    def close(self) -> None: ...
+
+def binhex(inp: str, out: str) -> None: ...
+
+class HexBin:
+    def __init__(self, ifp: _FileHandleUnion) -> None: ...
+    def read(self, *n: int) -> bytes: ...
+    def close_data(self) -> None: ...
+    def read_rsrc(self, *n: int) -> bytes: ...
+    def close(self) -> None: ...
+
+def hexbin(inp: str, out: str) -> None: ...

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

@@ -6497,5 +6497,4 @@ if sys.version_info >= (3, 11):
         ) -> tuple[ExceptionGroup[_ExceptionT_co] | None, ExceptionGroup[_ExceptionT_co] | None]: ...
 
 if sys.version_info >= (3, 13):
-    class IncompleteInputError(SyntaxError): ...
     class PythonFinalizationError(RuntimeError): ...

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

@@ -131,16 +131,69 @@ class BZ2File(BaseStream, IO[bytes]):
 
 @final
 class BZ2Compressor:
+    """
+    Create a compressor object for compressing data incrementally.
+
+      compresslevel
+        Compression level, as a number between 1 and 9.
+
+    For one-shot compression, use the compress() function instead.
+    """
     def __init__(self, compresslevel: int = ...) -> None: ...
-    def compress(self, data: ReadableBuffer, /) -> bytes: ...
-    def flush(self) -> bytes: ...
+    def compress(self, data: ReadableBuffer, /) -> bytes:
+        """
+        Provide data to the compressor object.
+
+        Returns a chunk of compressed data if possible, or b'' otherwise.
+
+        When you have finished providing data to the compressor, call the
+        flush() method to finish the compression process.
+        """
+        ...
+    def flush(self) -> bytes:
+        """
+        Finish the compression process.
+
+        Returns the compressed data left in internal buffers.
+
+        The compressor object may not be used after this method is called.
+        """
+        ...
 
 @final
 class BZ2Decompressor:
-    def decompress(self, data: ReadableBuffer, max_length: int = -1) -> bytes: ...
+    """
+    Create a decompressor object for decompressing data incrementally.
+
+    For one-shot decompression, use the decompress() function instead.
+    """
+    def decompress(self, data: ReadableBuffer, max_length: int = -1) -> bytes:
+        """
+        Decompress *data*, returning uncompressed data as bytes.
+
+        If *max_length* is nonnegative, returns at most *max_length* bytes of
+        decompressed data. If this limit is reached and further output can be
+        produced, *self.needs_input* will be set to ``False``. In this case, the next
+        call to *decompress()* may provide *data* as b'' to obtain more of the output.
+
+        If all of the input data was decompressed and returned (either because this
+        was less than *max_length* bytes, or because *max_length* was negative),
+        *self.needs_input* will be set to True.
+
+        Attempting to decompress data after the end of stream is reached raises an
+        EOFError.  Any data found after the end of the stream is ignored and saved in
+        the unused_data attribute.
+        """
+        ...
     @property
-    def eof(self) -> bool: ...
+    def eof(self) -> bool:
+        """True if the end-of-stream marker has been reached."""
+        ...
     @property
-    def needs_input(self) -> bool: ...
+    def needs_input(self) -> bool:
+        """True if more input is needed before more decompressed data can be produced."""
+        ...
     @property
-    def unused_data(self) -> bytes: ...
+    def unused_data(self) -> bytes:
+        """Data found after the end of the compressed stream."""
+        ...

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

@@ -1,112 +1,112 @@
-"""
-This module provides access to mathematical functions for complex
-numbers.
-"""
-
-from typing import SupportsComplex, SupportsFloat, SupportsIndex
-from typing_extensions import TypeAlias
-
-e: float
-pi: float
-inf: float
-infj: complex
-nan: float
-nanj: complex
-tau: float
-
-_C: TypeAlias = SupportsFloat | SupportsComplex | SupportsIndex | complex
-
-def acos(z: _C, /) -> complex:
-    """Return the arc cosine of z."""
-    ...
-def acosh(z: _C, /) -> complex:
-    """Return the inverse hyperbolic cosine of z."""
-    ...
-def asin(z: _C, /) -> complex:
-    """Return the arc sine of z."""
-    ...
-def asinh(z: _C, /) -> complex:
-    """Return the inverse hyperbolic sine of z."""
-    ...
-def atan(z: _C, /) -> complex:
-    """Return the arc tangent of z."""
-    ...
-def atanh(z: _C, /) -> complex:
-    """Return the inverse hyperbolic tangent of z."""
-    ...
-def cos(z: _C, /) -> complex:
-    """Return the cosine of z."""
-    ...
-def cosh(z: _C, /) -> complex:
-    """Return the hyperbolic cosine of z."""
-    ...
-def exp(z: _C, /) -> complex:
-    """Return the exponential value e**z."""
-    ...
-def isclose(a: _C, b: _C, *, rel_tol: SupportsFloat = 1e-09, abs_tol: SupportsFloat = 0.0) -> bool:
-    """
-    Determine whether two complex numbers are close in value.
-
-      rel_tol
-        maximum difference for being considered "close", relative to the
-        magnitude of the input values
-      abs_tol
-        maximum difference for being considered "close", regardless of the
-        magnitude of the input values
-
-    Return True if a is close in value to b, and False otherwise.
-
-    For the values to be considered close, the difference between them must be
-    smaller than at least one of the tolerances.
-
-    -inf, inf and NaN behave similarly to the IEEE 754 Standard. That is, NaN is
-    not close to anything, even itself. inf and -inf are only close to themselves.
-    """
-    ...
-def isinf(z: _C, /) -> bool:
-    """Checks if the real or imaginary part of z is infinite."""
-    ...
-def isnan(z: _C, /) -> bool:
-    """Checks if the real or imaginary part of z not a number (NaN)."""
-    ...
-def log(x: _C, base: _C = ..., /) -> complex:
-    """
-    log(z[, base]) -> the logarithm of z to the given base.
-
-    If the base not specified, returns the natural logarithm (base e) of z.
-    """
-    ...
-def log10(z: _C, /) -> complex:
-    """Return the base-10 logarithm of z."""
-    ...
-def phase(z: _C, /) -> float:
-    """Return argument, also known as the phase angle, of a complex."""
-    ...
-def polar(z: _C, /) -> tuple[float, float]:
-    """
-    Convert a complex from rectangular coordinates to polar coordinates.
-
-    r is the distance from 0 and phi the phase angle.
-    """
-    ...
-def rect(r: float, phi: float, /) -> complex:
-    """Convert from polar coordinates to rectangular coordinates."""
-    ...
-def sin(z: _C, /) -> complex:
-    """Return the sine of z."""
-    ...
-def sinh(z: _C, /) -> complex:
-    """Return the hyperbolic sine of z."""
-    ...
-def sqrt(z: _C, /) -> complex:
-    """Return the square root of z."""
-    ...
-def tan(z: _C, /) -> complex:
-    """Return the tangent of z."""
-    ...
-def tanh(z: _C, /) -> complex:
-    """Return the hyperbolic tangent of z."""
-    ...
-def isfinite(z: _C, /) -> bool:
-    """Return True if both the real and imaginary parts of z are finite, else False."""
-    ...
+"""
+This module provides access to mathematical functions for complex
+numbers.
+"""
+
+from typing import SupportsComplex, SupportsFloat, SupportsIndex
+from typing_extensions import TypeAlias
+
+e: float
+pi: float
+inf: float
+infj: complex
+nan: float
+nanj: complex
+tau: float
+
+_C: TypeAlias = SupportsFloat | SupportsComplex | SupportsIndex | complex
+
+def acos(z: _C, /) -> complex:
+    """Return the arc cosine of z."""
+    ...
+def acosh(z: _C, /) -> complex:
+    """Return the inverse hyperbolic cosine of z."""
+    ...
+def asin(z: _C, /) -> complex:
+    """Return the arc sine of z."""
+    ...
+def asinh(z: _C, /) -> complex:
+    """Return the inverse hyperbolic sine of z."""
+    ...
+def atan(z: _C, /) -> complex:
+    """Return the arc tangent of z."""
+    ...
+def atanh(z: _C, /) -> complex:
+    """Return the inverse hyperbolic tangent of z."""
+    ...
+def cos(z: _C, /) -> complex:
+    """Return the cosine of z."""
+    ...
+def cosh(z: _C, /) -> complex:
+    """Return the hyperbolic cosine of z."""
+    ...
+def exp(z: _C, /) -> complex:
+    """Return the exponential value e**z."""
+    ...
+def isclose(a: _C, b: _C, *, rel_tol: SupportsFloat = 1e-09, abs_tol: SupportsFloat = 0.0) -> bool:
+    """
+    Determine whether two complex numbers are close in value.
+
+      rel_tol
+        maximum difference for being considered "close", relative to the
+        magnitude of the input values
+      abs_tol
+        maximum difference for being considered "close", regardless of the
+        magnitude of the input values
+
+    Return True if a is close in value to b, and False otherwise.
+
+    For the values to be considered close, the difference between them must be
+    smaller than at least one of the tolerances.
+
+    -inf, inf and NaN behave similarly to the IEEE 754 Standard. That is, NaN is
+    not close to anything, even itself. inf and -inf are only close to themselves.
+    """
+    ...
+def isinf(z: _C, /) -> bool:
+    """Checks if the real or imaginary part of z is infinite."""
+    ...
+def isnan(z: _C, /) -> bool:
+    """Checks if the real or imaginary part of z not a number (NaN)."""
+    ...
+def log(x: _C, base: _C = ..., /) -> complex:
+    """
+    log(z[, base]) -> the logarithm of z to the given base.
+
+    If the base not specified, returns the natural logarithm (base e) of z.
+    """
+    ...
+def log10(z: _C, /) -> complex:
+    """Return the base-10 logarithm of z."""
+    ...
+def phase(z: _C, /) -> float:
+    """Return argument, also known as the phase angle, of a complex."""
+    ...
+def polar(z: _C, /) -> tuple[float, float]:
+    """
+    Convert a complex from rectangular coordinates to polar coordinates.
+
+    r is the distance from 0 and phi the phase angle.
+    """
+    ...
+def rect(r: float, phi: float, /) -> complex:
+    """Convert from polar coordinates to rectangular coordinates."""
+    ...
+def sin(z: _C, /) -> complex:
+    """Return the sine of z."""
+    ...
+def sinh(z: _C, /) -> complex:
+    """Return the hyperbolic sine of z."""
+    ...
+def sqrt(z: _C, /) -> complex:
+    """Return the square root of z."""
+    ...
+def tan(z: _C, /) -> complex:
+    """Return the tangent of z."""
+    ...
+def tanh(z: _C, /) -> complex:
+    """Return the hyperbolic tangent of z."""
+    ...
+def isfinite(z: _C, /) -> bool:
+    """Return True if both the real and imaginary parts of z are finite, else False."""
+    ...

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

@@ -146,12 +146,24 @@ BOM_UTF32: Literal[b"\xff\xfe\x00\x00", b"\x00\x00\xfe\xff"]  # depends on `sys.
 BOM_UTF32_BE: Literal[b"\x00\x00\xfe\xff"]
 BOM_UTF32_LE: Literal[b"\xff\xfe\x00\x00"]
 
-def strict_errors(exception: UnicodeError) -> tuple[str | bytes, int]: ...
-def replace_errors(exception: UnicodeError) -> tuple[str | bytes, int]: ...
-def ignore_errors(exception: UnicodeError) -> tuple[str | bytes, int]: ...
-def xmlcharrefreplace_errors(exception: UnicodeError) -> tuple[str | bytes, int]: ...
-def backslashreplace_errors(exception: UnicodeError) -> tuple[str | bytes, int]: ...
-def namereplace_errors(exception: UnicodeError) -> tuple[str | bytes, int]: ...
+def strict_errors(exception: UnicodeError) -> tuple[str | bytes, int]:
+    """Implements the 'strict' error handling, which raises a UnicodeError on coding errors."""
+    ...
+def replace_errors(exception: UnicodeError) -> tuple[str | bytes, int]:
+    """Implements the 'replace' error handling, which replaces malformed data with a replacement marker."""
+    ...
+def ignore_errors(exception: UnicodeError) -> tuple[str | bytes, int]:
+    """Implements the 'ignore' error handling, which ignores malformed data and continues."""
+    ...
+def xmlcharrefreplace_errors(exception: UnicodeError) -> tuple[str | bytes, int]:
+    """Implements the 'xmlcharrefreplace' error handling, which replaces an unencodable character with the appropriate XML character reference."""
+    ...
+def backslashreplace_errors(exception: UnicodeError) -> tuple[str | bytes, int]:
+    """Implements the 'backslashreplace' error handling, which replaces malformed data with a backslashed escape sequence."""
+    ...
+def namereplace_errors(exception: UnicodeError) -> tuple[str | bytes, int]:
+    r"""Implements the 'namereplace' error handling, which replaces an unencodable character with a \N{...} escape sequence."""
+    ...
 
 class Codec:
     # These are sort of @abstractmethod but sort of not.