basedpyright 1.13.1 → 1.13.2

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

@@ -1,95 +1,95 @@
-from typing_extensions import Buffer, TypeAlias
-
-_AdpcmState: TypeAlias = tuple[int, int]
-_RatecvState: TypeAlias = tuple[int, tuple[tuple[int, int], ...]]
-
-class error(Exception): ...
-
-def add(fragment1: Buffer, fragment2: Buffer, width: int, /) -> bytes:
-    """Return a fragment which is the addition of the two samples passed as parameters."""
-    ...
-def adpcm2lin(fragment: Buffer, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]:
-    """Decode an Intel/DVI ADPCM coded fragment to a linear fragment."""
-    ...
-def alaw2lin(fragment: Buffer, width: int, /) -> bytes:
-    """Convert sound fragments in a-LAW encoding to linearly encoded sound fragments."""
-    ...
-def avg(fragment: Buffer, width: int, /) -> int:
-    """Return the average over all samples in the fragment."""
-    ...
-def avgpp(fragment: Buffer, width: int, /) -> int:
-    """Return the average peak-peak value over all samples in the fragment."""
-    ...
-def bias(fragment: Buffer, width: int, bias: int, /) -> bytes:
-    """Return a fragment that is the original fragment with a bias added to each sample."""
-    ...
-def byteswap(fragment: Buffer, width: int, /) -> bytes:
-    """Convert big-endian samples to little-endian and vice versa."""
-    ...
-def cross(fragment: Buffer, width: int, /) -> int:
-    """Return the number of zero crossings in the fragment passed as an argument."""
-    ...
-def findfactor(fragment: Buffer, reference: Buffer, /) -> float:
-    """Return a factor F such that rms(add(fragment, mul(reference, -F))) is minimal."""
-    ...
-def findfit(fragment: Buffer, reference: Buffer, /) -> tuple[int, float]:
-    """Try to match reference as well as possible to a portion of fragment."""
-    ...
-def findmax(fragment: Buffer, length: int, /) -> int:
-    """Search fragment for a slice of specified number of samples with maximum energy."""
-    ...
-def getsample(fragment: Buffer, width: int, index: int, /) -> int:
-    """Return the value of sample index from the fragment."""
-    ...
-def lin2adpcm(fragment: Buffer, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]:
-    """Convert samples to 4 bit Intel/DVI ADPCM encoding."""
-    ...
-def lin2alaw(fragment: Buffer, width: int, /) -> bytes:
-    """Convert samples in the audio fragment to a-LAW encoding."""
-    ...
-def lin2lin(fragment: Buffer, width: int, newwidth: int, /) -> bytes:
-    """Convert samples between 1-, 2-, 3- and 4-byte formats."""
-    ...
-def lin2ulaw(fragment: Buffer, width: int, /) -> bytes:
-    """Convert samples in the audio fragment to u-LAW encoding."""
-    ...
-def max(fragment: Buffer, width: int, /) -> int:
-    """Return the maximum of the absolute value of all samples in a fragment."""
-    ...
-def maxpp(fragment: Buffer, width: int, /) -> int:
-    """Return the maximum peak-peak value in the sound fragment."""
-    ...
-def minmax(fragment: Buffer, width: int, /) -> tuple[int, int]:
-    """Return the minimum and maximum values of all samples in the sound fragment."""
-    ...
-def mul(fragment: Buffer, width: int, factor: float, /) -> bytes:
-    """Return a fragment that has all samples in the original fragment multiplied by the floating-point value factor."""
-    ...
-def ratecv(
-    fragment: Buffer,
-    width: int,
-    nchannels: int,
-    inrate: int,
-    outrate: int,
-    state: _RatecvState | None,
-    weightA: int = 1,
-    weightB: int = 0,
-    /,
-) -> tuple[bytes, _RatecvState]:
-    """Convert the frame rate of the input fragment."""
-    ...
-def reverse(fragment: Buffer, width: int, /) -> bytes:
-    """Reverse the samples in a fragment and returns the modified fragment."""
-    ...
-def rms(fragment: Buffer, width: int, /) -> int:
-    """Return the root-mean-square of the fragment, i.e. sqrt(sum(S_i^2)/n)."""
-    ...
-def tomono(fragment: Buffer, width: int, lfactor: float, rfactor: float, /) -> bytes:
-    """Convert a stereo fragment to a mono fragment."""
-    ...
-def tostereo(fragment: Buffer, width: int, lfactor: float, rfactor: float, /) -> bytes:
-    """Generate a stereo fragment from a mono fragment."""
-    ...
-def ulaw2lin(fragment: Buffer, width: int, /) -> bytes:
-    """Convert sound fragments in u-LAW encoding to linearly encoded sound fragments."""
-    ...
+from typing_extensions import Buffer, TypeAlias
+
+_AdpcmState: TypeAlias = tuple[int, int]
+_RatecvState: TypeAlias = tuple[int, tuple[tuple[int, int], ...]]
+
+class error(Exception): ...
+
+def add(fragment1: Buffer, fragment2: Buffer, width: int, /) -> bytes:
+    """Return a fragment which is the addition of the two samples passed as parameters."""
+    ...
+def adpcm2lin(fragment: Buffer, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]:
+    """Decode an Intel/DVI ADPCM coded fragment to a linear fragment."""
+    ...
+def alaw2lin(fragment: Buffer, width: int, /) -> bytes:
+    """Convert sound fragments in a-LAW encoding to linearly encoded sound fragments."""
+    ...
+def avg(fragment: Buffer, width: int, /) -> int:
+    """Return the average over all samples in the fragment."""
+    ...
+def avgpp(fragment: Buffer, width: int, /) -> int:
+    """Return the average peak-peak value over all samples in the fragment."""
+    ...
+def bias(fragment: Buffer, width: int, bias: int, /) -> bytes:
+    """Return a fragment that is the original fragment with a bias added to each sample."""
+    ...
+def byteswap(fragment: Buffer, width: int, /) -> bytes:
+    """Convert big-endian samples to little-endian and vice versa."""
+    ...
+def cross(fragment: Buffer, width: int, /) -> int:
+    """Return the number of zero crossings in the fragment passed as an argument."""
+    ...
+def findfactor(fragment: Buffer, reference: Buffer, /) -> float:
+    """Return a factor F such that rms(add(fragment, mul(reference, -F))) is minimal."""
+    ...
+def findfit(fragment: Buffer, reference: Buffer, /) -> tuple[int, float]:
+    """Try to match reference as well as possible to a portion of fragment."""
+    ...
+def findmax(fragment: Buffer, length: int, /) -> int:
+    """Search fragment for a slice of specified number of samples with maximum energy."""
+    ...
+def getsample(fragment: Buffer, width: int, index: int, /) -> int:
+    """Return the value of sample index from the fragment."""
+    ...
+def lin2adpcm(fragment: Buffer, width: int, state: _AdpcmState | None, /) -> tuple[bytes, _AdpcmState]:
+    """Convert samples to 4 bit Intel/DVI ADPCM encoding."""
+    ...
+def lin2alaw(fragment: Buffer, width: int, /) -> bytes:
+    """Convert samples in the audio fragment to a-LAW encoding."""
+    ...
+def lin2lin(fragment: Buffer, width: int, newwidth: int, /) -> bytes:
+    """Convert samples between 1-, 2-, 3- and 4-byte formats."""
+    ...
+def lin2ulaw(fragment: Buffer, width: int, /) -> bytes:
+    """Convert samples in the audio fragment to u-LAW encoding."""
+    ...
+def max(fragment: Buffer, width: int, /) -> int:
+    """Return the maximum of the absolute value of all samples in a fragment."""
+    ...
+def maxpp(fragment: Buffer, width: int, /) -> int:
+    """Return the maximum peak-peak value in the sound fragment."""
+    ...
+def minmax(fragment: Buffer, width: int, /) -> tuple[int, int]:
+    """Return the minimum and maximum values of all samples in the sound fragment."""
+    ...
+def mul(fragment: Buffer, width: int, factor: float, /) -> bytes:
+    """Return a fragment that has all samples in the original fragment multiplied by the floating-point value factor."""
+    ...
+def ratecv(
+    fragment: Buffer,
+    width: int,
+    nchannels: int,
+    inrate: int,
+    outrate: int,
+    state: _RatecvState | None,
+    weightA: int = 1,
+    weightB: int = 0,
+    /,
+) -> tuple[bytes, _RatecvState]:
+    """Convert the frame rate of the input fragment."""
+    ...
+def reverse(fragment: Buffer, width: int, /) -> bytes:
+    """Reverse the samples in a fragment and returns the modified fragment."""
+    ...
+def rms(fragment: Buffer, width: int, /) -> int:
+    """Return the root-mean-square of the fragment, i.e. sqrt(sum(S_i^2)/n)."""
+    ...
+def tomono(fragment: Buffer, width: int, lfactor: float, rfactor: float, /) -> bytes:
+    """Convert a stereo fragment to a mono fragment."""
+    ...
+def tostereo(fragment: Buffer, width: int, lfactor: float, rfactor: float, /) -> bytes:
+    """Generate a stereo fragment from a mono fragment."""
+    ...
+def ulaw2lin(fragment: Buffer, width: int, /) -> bytes:
+    """Convert sound fragments in u-LAW encoding to linearly encoded sound fragments."""
+    ...

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

@@ -1,123 +1,123 @@
-"""Conversion between binary data and ASCII"""
-
-import sys
-from _typeshed import ReadableBuffer
-from typing_extensions import TypeAlias
-
-# Many functions in binascii accept buffer objects
-# or ASCII-only strings.
-_AsciiBuffer: TypeAlias = str | ReadableBuffer
-
-def a2b_uu(data: _AsciiBuffer, /) -> bytes:
-    """Decode a line of uuencoded data."""
-    ...
-def b2a_uu(data: ReadableBuffer, /, *, backtick: bool = False) -> bytes:
-    """Uuencode line of data."""
-    ...
-
-if sys.version_info >= (3, 11):
-    def a2b_base64(data: _AsciiBuffer, /, *, strict_mode: bool = False) -> bytes:
-        """
-        Decode a line of base64 data.
-
-        strict_mode
-          When set to True, bytes that are not part of the base64 standard are not allowed.
-          The same applies to excess data after padding (= / ==).
-        """
-        ...
-
-else:
-    def a2b_base64(data: _AsciiBuffer, /) -> bytes:
-        """Decode a line of base64 data."""
-        ...
-
-def b2a_base64(data: ReadableBuffer, /, *, newline: bool = True) -> bytes:
-    """Base64-code line of data."""
-    ...
-def a2b_qp(data: _AsciiBuffer, header: bool = False) -> bytes:
-    """Decode a string of qp-encoded data."""
-    ...
-def b2a_qp(data: ReadableBuffer, quotetabs: bool = False, istext: bool = True, header: bool = False) -> bytes:
-    r"""
-    Encode a string using quoted-printable encoding.
-
-    On encoding, when istext is set, newlines are not encoded, and white
-    space at end of lines is.  When istext is not set, \r and \n (CR/LF)
-    are both encoded.  When quotetabs is set, space and tabs are encoded.
-    """
-    ...
-
-if sys.version_info < (3, 11):
-    def a2b_hqx(data: _AsciiBuffer, /) -> bytes:
-        """Decode .hqx coding."""
-        ...
-    def rledecode_hqx(data: ReadableBuffer, /) -> bytes:
-        """Decode hexbin RLE-coded string."""
-        ...
-    def rlecode_hqx(data: ReadableBuffer, /) -> bytes:
-        """Binhex RLE-code binary data."""
-        ...
-    def b2a_hqx(data: ReadableBuffer, /) -> bytes:
-        """Encode .hqx data."""
-        ...
-
-def crc_hqx(data: ReadableBuffer, crc: int, /) -> int:
-    """Compute CRC-CCITT incrementally."""
-    ...
-def crc32(data: ReadableBuffer, crc: int = 0, /) -> int:
-    """Compute CRC-32 incrementally."""
-    ...
-def b2a_hex(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = ...) -> bytes:
-    r"""
-    Hexadecimal representation of binary data.
-
-      sep
-        An optional single character or byte to separate hex bytes.
-      bytes_per_sep
-        How many bytes between separators.  Positive values count from the
-        right, negative values count from the left.
-
-    The return value is a bytes object.  This function is also
-    available as "hexlify()".
-
-    Example:
-    >>> binascii.b2a_hex(b'\xb9\x01\xef')
-    b'b901ef'
-    >>> binascii.hexlify(b'\xb9\x01\xef', ':')
-    b'b9:01:ef'
-    >>> binascii.b2a_hex(b'\xb9\x01\xef', b'_', 2)
-    b'b9_01ef'
-    """
-    ...
-def hexlify(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = ...) -> bytes:
-    """
-    Hexadecimal representation of binary data.
-
-      sep
-        An optional single character or byte to separate hex bytes.
-      bytes_per_sep
-        How many bytes between separators.  Positive values count from the
-        right, negative values count from the left.
-
-    The return value is a bytes object.  This function is also
-    available as "b2a_hex()".
-    """
-    ...
-def a2b_hex(hexstr: _AsciiBuffer, /) -> bytes:
-    """
-    Binary data of hexadecimal representation.
-
-    hexstr must contain an even number of hex digits (upper or lower case).
-    This function is also available as "unhexlify()".
-    """
-    ...
-def unhexlify(hexstr: _AsciiBuffer, /) -> bytes:
-    """
-    Binary data of hexadecimal representation.
-
-    hexstr must contain an even number of hex digits (upper or lower case).
-    """
-    ...
-
-class Error(ValueError): ...
-class Incomplete(Exception): ...
+"""Conversion between binary data and ASCII"""
+
+import sys
+from _typeshed import ReadableBuffer
+from typing_extensions import TypeAlias
+
+# Many functions in binascii accept buffer objects
+# or ASCII-only strings.
+_AsciiBuffer: TypeAlias = str | ReadableBuffer
+
+def a2b_uu(data: _AsciiBuffer, /) -> bytes:
+    """Decode a line of uuencoded data."""
+    ...
+def b2a_uu(data: ReadableBuffer, /, *, backtick: bool = False) -> bytes:
+    """Uuencode line of data."""
+    ...
+
+if sys.version_info >= (3, 11):
+    def a2b_base64(data: _AsciiBuffer, /, *, strict_mode: bool = False) -> bytes:
+        """
+        Decode a line of base64 data.
+
+        strict_mode
+          When set to True, bytes that are not part of the base64 standard are not allowed.
+          The same applies to excess data after padding (= / ==).
+        """
+        ...
+
+else:
+    def a2b_base64(data: _AsciiBuffer, /) -> bytes:
+        """Decode a line of base64 data."""
+        ...
+
+def b2a_base64(data: ReadableBuffer, /, *, newline: bool = True) -> bytes:
+    """Base64-code line of data."""
+    ...
+def a2b_qp(data: _AsciiBuffer, header: bool = False) -> bytes:
+    """Decode a string of qp-encoded data."""
+    ...
+def b2a_qp(data: ReadableBuffer, quotetabs: bool = False, istext: bool = True, header: bool = False) -> bytes:
+    r"""
+    Encode a string using quoted-printable encoding.
+
+    On encoding, when istext is set, newlines are not encoded, and white
+    space at end of lines is.  When istext is not set, \r and \n (CR/LF)
+    are both encoded.  When quotetabs is set, space and tabs are encoded.
+    """
+    ...
+
+if sys.version_info < (3, 11):
+    def a2b_hqx(data: _AsciiBuffer, /) -> bytes:
+        """Decode .hqx coding."""
+        ...
+    def rledecode_hqx(data: ReadableBuffer, /) -> bytes:
+        """Decode hexbin RLE-coded string."""
+        ...
+    def rlecode_hqx(data: ReadableBuffer, /) -> bytes:
+        """Binhex RLE-code binary data."""
+        ...
+    def b2a_hqx(data: ReadableBuffer, /) -> bytes:
+        """Encode .hqx data."""
+        ...
+
+def crc_hqx(data: ReadableBuffer, crc: int, /) -> int:
+    """Compute CRC-CCITT incrementally."""
+    ...
+def crc32(data: ReadableBuffer, crc: int = 0, /) -> int:
+    """Compute CRC-32 incrementally."""
+    ...
+def b2a_hex(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = ...) -> bytes:
+    r"""
+    Hexadecimal representation of binary data.
+
+      sep
+        An optional single character or byte to separate hex bytes.
+      bytes_per_sep
+        How many bytes between separators.  Positive values count from the
+        right, negative values count from the left.
+
+    The return value is a bytes object.  This function is also
+    available as "hexlify()".
+
+    Example:
+    >>> binascii.b2a_hex(b'\xb9\x01\xef')
+    b'b901ef'
+    >>> binascii.hexlify(b'\xb9\x01\xef', ':')
+    b'b9:01:ef'
+    >>> binascii.b2a_hex(b'\xb9\x01\xef', b'_', 2)
+    b'b9_01ef'
+    """
+    ...
+def hexlify(data: ReadableBuffer, sep: str | bytes = ..., bytes_per_sep: int = ...) -> bytes:
+    """
+    Hexadecimal representation of binary data.
+
+      sep
+        An optional single character or byte to separate hex bytes.
+      bytes_per_sep
+        How many bytes between separators.  Positive values count from the
+        right, negative values count from the left.
+
+    The return value is a bytes object.  This function is also
+    available as "b2a_hex()".
+    """
+    ...
+def a2b_hex(hexstr: _AsciiBuffer, /) -> bytes:
+    """
+    Binary data of hexadecimal representation.
+
+    hexstr must contain an even number of hex digits (upper or lower case).
+    This function is also available as "unhexlify()".
+    """
+    ...
+def unhexlify(hexstr: _AsciiBuffer, /) -> bytes:
+    """
+    Binary data of hexadecimal representation.
+
+    hexstr must contain an even number of hex digits (upper or lower case).
+    """
+    ...
+
+class Error(ValueError): ...
+class Incomplete(Exception): ...

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."""
+    ...