basedpyright 1.40.1 → 1.40.2

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

@@ -110,12 +110,14 @@ class Decimal:
         ...
     def compare(self, other: _Decimal, context: Context | None = None) -> Decimal:
         """
-        Compare self to other.  Return a decimal value:
+        Compare self to other.
 
-        a or b is a NaN ==> Decimal('NaN')
-        a < b           ==> Decimal('-1')
-        a == b          ==> Decimal('0')
-        a > b           ==> Decimal('1')
+        Return a decimal value:
+
+            a or b is a NaN ==> Decimal('NaN')
+            a < b           ==> Decimal('-1')
+            a == b          ==> Decimal('0')
+            a > b           ==> Decimal('1')
         """
         ...
     def __hash__(self) -> int:
@@ -126,21 +128,23 @@ class Decimal:
         ...
     def as_integer_ratio(self) -> tuple[int, int]:
         """
-        Decimal.as_integer_ratio() -> (int, int)
+        Return a pair of integers whose ratio is exactly equal to the original.
 
-        Return a pair of integers, whose ratio is exactly equal to the original
-        Decimal and with a positive denominator. The ratio is in lowest terms.
+        The ratio is in lowest terms and with a positive denominator.
         Raise OverflowError on infinities and a ValueError on NaNs.
         """
         ...
     def to_eng_string(self, context: Context | None = None) -> str:
         """
-        Convert to an engineering-type string.  Engineering notation has an exponent
-        which is a multiple of 3, so there are up to 3 digits left of the decimal
-        place. For example, Decimal('123E+1') is converted to Decimal('1.23E+3').
+        Convert to an engineering-type string.
+
+        Engineering notation has an exponent which is a multiple of 3, so
+        there are up to 3 digits left of the decimal place.  For example,
+        Decimal('123E+1') is converted to Decimal('1.23E+3').
 
-        The value of context.capitals determines whether the exponent sign is lower
-        or upper case. Otherwise, the context does not affect the operation.
+        The value of context.capitals determines whether the exponent sign
+        is lower or upper case.  Otherwise, the context does not affect the
+        operation.
         """
         ...
     def __abs__(self) -> Decimal:
@@ -214,11 +218,13 @@ class Decimal:
         ...
     def remainder_near(self, other: _Decimal, context: Context | None = None) -> Decimal:
         """
-        Return the remainder from dividing self by other.  This differs from
-        self % other in that the sign of the remainder is chosen so as to minimize
-        its absolute value. More precisely, the return value is self - n * other
-        where n is the integer nearest to the exact value of self / other, and
-        if two integers are equally near then the even one is chosen.
+        Return the remainder from dividing self by other.
+
+        This differs from self % other in that the sign of the remainder is
+        chosen so as to minimize its absolute value. More precisely, the
+        return value is self - n * other where n is the integer nearest to
+        the exact value of self / other, and if two integers are equally
+        near then the even one is chosen.
 
         If the result is zero then its sign will be the sign of self.
         """
@@ -229,7 +235,9 @@ class Decimal:
     def __int__(self) -> int:
         """int(self)"""
         ...
-    def __trunc__(self) -> int: ...
+    def __trunc__(self) -> int:
+        """Return the Integral closest to x between 0 and x."""
+        ...
     @property
     def real(self) -> Decimal: ...
     @property
@@ -237,19 +245,31 @@ class Decimal:
     def conjugate(self) -> Decimal:
         """Return self."""
         ...
-    def __complex__(self) -> complex: ...
+    def __complex__(self) -> complex:
+        """Convert this value to exact type complex."""
+        ...
 
     @overload
-    def __round__(self) -> int: ...
+    def __round__(self) -> int:
+        """Return the Integral closest to self, rounding half toward even."""
+        ...
     @overload
-    def __round__(self, ndigits: int, /) -> Decimal: ...
+    def __round__(self, ndigits: int, /) -> Decimal:
+        """Return the Integral closest to self, rounding half toward even."""
+        ...
 
-    def __floor__(self) -> int: ...
-    def __ceil__(self) -> int: ...
+    def __floor__(self) -> int:
+        """Return the floor as an Integral."""
+        ...
+    def __ceil__(self) -> int:
+        """Return the ceiling as an Integral."""
+        ...
     def fma(self, other: _Decimal, third: _Decimal, context: Context | None = None) -> Decimal:
         """
-        Fused multiply-add.  Return self*other+third with no rounding of the
-        intermediate product self*other.
+        Fused multiply-add.
+
+        Return self*other+third with no rounding of the intermediate product
+        self*other.
 
             >>> Decimal(2).fma(3, 5)
             Decimal('11')
@@ -260,92 +280,110 @@ class Decimal:
         ...
     def normalize(self, context: Context | None = None) -> Decimal:
         """
-        Normalize the number by stripping the rightmost trailing zeros and
-        converting any result equal to Decimal('0') to Decimal('0e0').  Used
-        for producing canonical values for members of an equivalence class.
-        For example, Decimal('32.100') and Decimal('0.321000e+2') both normalize
-        to the equivalent value Decimal('32.1').
+        Normalize the number by stripping trailing 0s
+
+        This also change anything equal to 0 to 0e0.  Used for producing
+        canonical values for members of an equivalence class.  For example,
+        Decimal('32.100') and Decimal('0.321000e+2') both normalize to
+        the equivalent value Decimal('32.1').
         """
         ...
     def quantize(self, exp: _Decimal, rounding: str | None = None, context: Context | None = None) -> Decimal:
         """
-        Return a value equal to the first operand after rounding and having the
-        exponent of the second operand.
+        Quantize *self* so its exponent is the same as that of *exp*.
+
+        Return a value equal to *self* after rounding, with the exponent
+        of *exp*.
 
             >>> Decimal('1.41421356').quantize(Decimal('1.000'))
             Decimal('1.414')
 
-        Unlike other operations, if the length of the coefficient after the quantize
-        operation would be greater than precision, then an InvalidOperation is signaled.
-        This guarantees that, unless there is an error condition, the quantized exponent
-        is always equal to that of the right-hand operand.
+        Unlike other operations, if the length of the coefficient after the
+        quantize operation would be greater than precision, then an
+        InvalidOperation is signaled.  This guarantees that, unless there
+        is an error condition, the quantized exponent is always equal to
+        that of the right-hand operand.
 
-        Also unlike other operations, quantize never signals Underflow, even if the
-        result is subnormal and inexact.
+        Also unlike other operations, quantize never signals Underflow, even
+        if the result is subnormal and inexact.
 
-        If the exponent of the second operand is larger than that of the first, then
-        rounding may be necessary. In this case, the rounding mode is determined by the
-        rounding argument if given, else by the given context argument; if neither
-        argument is given, the rounding mode of the current thread's context is used.
+        If the exponent of the second operand is larger than that of the
+        first, then rounding may be necessary.  In this case, the rounding
+        mode is determined by the rounding argument if given, else by the
+        given context argument; if neither argument is given, the rounding
+        mode of the current thread's context is used.
         """
         ...
     def same_quantum(self, other: _Decimal, context: Context | None = None) -> bool:
         """
-        Test whether self and other have the same exponent or whether both are NaN.
+        Test whether self and other have the same exponent or both are NaN.
 
-        This operation is unaffected by context and is quiet: no flags are changed
-        and no rounding is performed. As an exception, the C version may raise
-        InvalidOperation if the second operand cannot be converted exactly.
+        This operation is unaffected by context and is quiet: no flags are
+        changed and no rounding is performed. As an exception, the C version
+        may raise InvalidOperation if the second operand cannot be converted
+        exactly.
         """
         ...
     def to_integral_exact(self, rounding: str | None = None, context: Context | None = None) -> Decimal:
         """
-        Round to the nearest integer, signaling Inexact or Rounded as appropriate if
-        rounding occurs.  The rounding mode is determined by the rounding parameter
-        if given, else by the given context. If neither parameter is given, then the
-        rounding mode of the current default context is used.
+        Round to the nearest integer.
+
+        This method signals Inexact or Rounded as appropriate if rounding
+        occurs.  The rounding mode is determined by the rounding parameter
+        if given, else by the given context.  If neither parameter is given,
+        then the rounding mode of the current default context is used.
         """
         ...
     def to_integral_value(self, rounding: str | None = None, context: Context | None = None) -> Decimal:
         """
-        Round to the nearest integer without signaling Inexact or Rounded.  The
-        rounding mode is determined by the rounding parameter if given, else by
-        the given context. If neither parameter is given, then the rounding mode
-        of the current default context is used.
+        Round to the nearest integer without signaling Inexact or Rounded.
+
+        The rounding mode is determined by the rounding parameter if given,
+        else by the given context. If neither parameter is given, then the
+        rounding mode of the current default context is used.
         """
         ...
     def to_integral(self, rounding: str | None = None, context: Context | None = None) -> Decimal:
         """
-        Identical to the to_integral_value() method.  The to_integral() name has been
-        kept for compatibility with older versions.
+        Identical to the to_integral_value() method.
+
+        The to_integral() name has been kept for compatibility with older
+        versions.
         """
         ...
     def sqrt(self, context: Context | None = None) -> Decimal:
         """
-        Return the square root of the argument to full precision. The result is
-        correctly rounded using the ROUND_HALF_EVEN rounding mode.
+        Return the square root of the argument to full precision.
+
+        The result is correctly rounded using the ROUND_HALF_EVEN rounding
+        mode.
         """
         ...
     def max(self, other: _Decimal, context: Context | None = None) -> Decimal:
         """
-        Maximum of self and other.  If one operand is a quiet NaN and the other is
-        numeric, the numeric operand is returned.
+        Maximum of self and other.
+
+        If one operand is a quiet NaN and the other is numeric, the numeric
+        operand is returned.
         """
         ...
     def min(self, other: _Decimal, context: Context | None = None) -> Decimal:
         """
-        Minimum of self and other. If one operand is a quiet NaN and the other is
-        numeric, the numeric operand is returned.
+        Minimum of self and other.
+
+        If one operand is a quiet NaN and the other is numeric, the numeric
+        operand is returned.
         """
         ...
     def adjusted(self) -> int:
-        """Return the adjusted exponent of the number.  Defined as exp + digits - 1."""
+        """Return the adjusted exponent (exp + digits - 1) of the number."""
         ...
     def canonical(self) -> Decimal:
         """
-        Return the canonical encoding of the argument.  Currently, the encoding
-        of a Decimal instance is always canonical, so this operation returns its
-        argument unchanged.
+        Return the canonical encoding of the argument.
+
+        Currently, the encoding of a Decimal instance is always canonical,
+        so this operation returns its argument unchanged.
         """
         ...
     def compare_signal(self, other: _Decimal, context: Context | None = None) -> Decimal:
@@ -353,100 +391,103 @@ class Decimal:
         ...
     def compare_total(self, other: _Decimal, context: Context | None = None) -> Decimal:
         """
-        Compare two operands using their abstract representation rather than
-        their numerical value.  Similar to the compare() method, but the result
-        gives a total ordering on Decimal instances.  Two Decimal instances with
-        the same numeric value but different representations compare unequal
-        in this ordering:
+        Compare two operands using their abstract representation.
+
+        Similar to the compare() method, but the result gives a total
+        ordering on Decimal instances.  Two Decimal instances with the same
+        numeric value but different representations compare unequal in this
+        ordering:
 
             >>> Decimal('12.0').compare_total(Decimal('12'))
             Decimal('-1')
 
-        Quiet and signaling NaNs are also included in the total ordering. The result
-        of this function is Decimal('0') if both operands have the same representation,
-        Decimal('-1') if the first operand is lower in the total order than the second,
-        and Decimal('1') if the first operand is higher in the total order than the
-        second operand. See the specification for details of the total order.
+        Quiet and signaling NaNs are also included in the total ordering.
+        The result of this function is Decimal('0') if both operands have
+        the same representation, Decimal('-1') if the first operand is lower
+        in the total order than the second, and Decimal('1') if the first
+        operand is higher in the total order than the second operand.  See
+        the specification for details of the total order.
 
-        This operation is unaffected by context and is quiet: no flags are changed
-        and no rounding is performed. As an exception, the C version may raise
-        InvalidOperation if the second operand cannot be converted exactly.
+        This operation is unaffected by context and is quiet: no flags are
+        changed and no rounding is performed.  As an exception, the C
+        version may raise InvalidOperation if the second operand cannot be
+        converted exactly.
         """
         ...
     def compare_total_mag(self, other: _Decimal, context: Context | None = None) -> Decimal:
         """
-        Compare two operands using their abstract representation rather than their
-        value as in compare_total(), but ignoring the sign of each operand.
+        As compare_total(), but ignores the sign of each operand.
 
-        x.compare_total_mag(y) is equivalent to x.copy_abs().compare_total(y.copy_abs()).
+        x.compare_total_mag(y) is equivalent to
+        x.copy_abs().compare_total(y.copy_abs()).
 
-        This operation is unaffected by context and is quiet: no flags are changed
-        and no rounding is performed. As an exception, the C version may raise
-        InvalidOperation if the second operand cannot be converted exactly.
+        This operation is unaffected by context and is quiet: no flags are
+        changed and no rounding is performed. As an exception, the C version
+        may raise InvalidOperation if the second operand cannot be converted
+        exactly.
         """
         ...
     def copy_abs(self) -> Decimal:
         """
-        Return the absolute value of the argument.  This operation is unaffected by
-        context and is quiet: no flags are changed and no rounding is performed.
+        Return the absolute value of the argument.
+
+        This operation is unaffected by context and is quiet: no flags are
+        changed and no rounding is performed.
         """
         ...
     def copy_negate(self) -> Decimal:
         """
-        Return the negation of the argument.  This operation is unaffected by context
-        and is quiet: no flags are changed and no rounding is performed.
+        Return the negation of the argument.
+
+        This operation is unaffected by context and is quiet: no flags are
+        changed and no rounding is performed.
         """
         ...
     def copy_sign(self, other: _Decimal, context: Context | None = None) -> Decimal:
         """
-        Return a copy of the first operand with the sign set to be the same as the
-        sign of the second operand. For example:
+        Return a copy of *self* with the sign of *other*.
+
+        For example:
 
             >>> Decimal('2.3').copy_sign(Decimal('-1.5'))
             Decimal('-2.3')
 
-        This operation is unaffected by context and is quiet: no flags are changed
-        and no rounding is performed. As an exception, the C version may raise
-        InvalidOperation if the second operand cannot be converted exactly.
+        This operation is unaffected by context and is quiet: no flags are
+        changed and no rounding is performed. As an exception, the C version
+        may raise InvalidOperation if the second operand cannot be converted
+        exactly.
         """
         ...
     def exp(self, context: Context | None = None) -> Decimal:
         """
-        Return the value of the (natural) exponential function e**x at the given
-        number.  The function always uses the ROUND_HALF_EVEN mode and the result
-        is correctly rounded.
+        Return the value of the (natural) exponential function e**x.
+
+        The function always uses the ROUND_HALF_EVEN mode and the result is
+        correctly rounded.
         """
         ...
     def is_canonical(self) -> bool:
         """
-        Return True if the argument is canonical and False otherwise.  Currently,
-        a Decimal instance is always canonical, so this operation always returns
-        True.
+        Return True if the argument is canonical and False otherwise.
+
+        Currently, a Decimal instance is always canonical, so this operation
+        always returns True.
         """
         ...
     def is_finite(self) -> bool:
-        """
-        Return True if the argument is a finite number, and False if the argument
-        is infinite or a NaN.
-        """
+        """Return True if the argument is a finite number, and False otherwise."""
         ...
     def is_infinite(self) -> bool:
-        """
-        Return True if the argument is either positive or negative infinity and
-        False otherwise.
-        """
+        """Return True if the argument is infinite, and False otherwise."""
         ...
     def is_nan(self) -> bool:
-        """
-        Return True if the argument is a (quiet or signaling) NaN and False
-        otherwise.
-        """
+        """Return True if the argument is a (quiet or signaling) NaN, else False."""
         ...
     def is_normal(self, context: Context | None = None) -> bool:
         """
-        Return True if the argument is a normal finite non-zero number with an
-        adjusted exponent greater than or equal to Emin. Return False if the
-        argument is zero, subnormal, infinite or a NaN.
+        Return True if the argument is a normal number and False otherwise.
+
+        Normal number is a finite nonzero number, which is not subnormal.
         """
         ...
     def is_qnan(self) -> bool:
@@ -455,6 +496,7 @@ class Decimal:
     def is_signed(self) -> bool:
         """
         Return True if the argument has a negative sign and False otherwise.
+
         Note that both zeros and NaNs can carry signs.
         """
         ...
@@ -463,35 +505,38 @@ class Decimal:
         ...
     def is_subnormal(self, context: Context | None = None) -> bool:
         """
-        Return True if the argument is subnormal, and False otherwise. A number is
-        subnormal if it is non-zero, finite, and has an adjusted exponent less
-        than Emin.
+        Return True if the argument is subnormal, and False otherwise.
+
+        A number is subnormal if it is non-zero, finite, and has an adjusted
+        exponent less than Emin.
         """
         ...
     def is_zero(self) -> bool:
-        """
-        Return True if the argument is a (positive or negative) zero and False
-        otherwise.
-        """
+        """Return True if the argument is a zero and False otherwise."""
         ...
     def ln(self, context: Context | None = None) -> Decimal:
         """
-        Return the natural (base e) logarithm of the operand. The function always
-        uses the ROUND_HALF_EVEN mode and the result is correctly rounded.
+        Return the natural (base e) logarithm of the operand.
+
+        The function always uses the ROUND_HALF_EVEN mode and the result is
+        correctly rounded.
         """
         ...
     def log10(self, context: Context | None = None) -> Decimal:
         """
-        Return the base ten logarithm of the operand. The function always uses the
-        ROUND_HALF_EVEN mode and the result is correctly rounded.
+        Return the base ten logarithm of the operand.
+
+        The function always uses the ROUND_HALF_EVEN mode and the result is
+        correctly rounded.
         """
         ...
     def logb(self, context: Context | None = None) -> Decimal:
         """
-        For a non-zero number, return the adjusted exponent of the operand as a
-        Decimal instance.  If the operand is a zero, then Decimal('-Infinity') is
-        returned and the DivisionByZero condition is raised. If the operand is
-        an infinity then Decimal('Infinity') is returned.
+        Return the adjusted exponent of the operand as a Decimal instance.
+
+        If the operand is a zero, then Decimal('-Infinity') is returned and
+        the DivisionByZero condition is raised.  If the operand is an
+        infinity then Decimal('Infinity') is returned.
         """
         ...
     def logical_and(self, other: _Decimal, context: Context | None = None) -> Decimal:
@@ -512,7 +557,7 @@ class Decimal:
         """
         Applies an 'or' operation between self and other's digits.
 
-        Both self and other must be logical numbers. 
+        Both self and other must be logical numbers.
         """
         ...
     def logical_xor(self, other: _Decimal, context: Context | None = None) -> Decimal:
@@ -523,96 +568,99 @@ class Decimal:
         """
         ...
     def max_mag(self, other: _Decimal, context: Context | None = None) -> Decimal:
-        """
-        Similar to the max() method, but the comparison is done using the absolute
-        values of the operands.
-        """
+        """As the max() method, but compares the absolute values of the operands."""
         ...
     def min_mag(self, other: _Decimal, context: Context | None = None) -> Decimal:
-        """
-        Similar to the min() method, but the comparison is done using the absolute
-        values of the operands.
-        """
+        """As the min() method, but compares the absolute values of the operands."""
         ...
     def next_minus(self, context: Context | None = None) -> Decimal:
-        """
-        Return the largest number representable in the given context (or in the
-        current default context if no context is given) that is smaller than the
-        given operand.
-        """
+        """Returns the largest representable number smaller than itself."""
         ...
     def next_plus(self, context: Context | None = None) -> Decimal:
-        """
-        Return the smallest number representable in the given context (or in the
-        current default context if no context is given) that is larger than the
-        given operand.
-        """
+        """Returns the smallest representable number larger than itself."""
         ...
     def next_toward(self, other: _Decimal, context: Context | None = None) -> Decimal:
         """
-        If the two operands are unequal, return the number closest to the first
-        operand in the direction of the second operand.  If both operands are
-        numerically equal, return a copy of the first operand with the sign set
-        to be the same as the sign of the second operand.
+        Returns the number closest to self, in the direction towards other.
+
+        If the two operands are unequal, return the number closest to the
+        first operand in the direction of the second operand.  If both
+        operands are numerically equal, return a copy of the first operand
+        with the sign set to be the same as the sign of the second operand.
         """
         ...
     def number_class(self, context: Context | None = None) -> str:
         """
-        Return a string describing the class of the operand.  The returned value
-        is one of the following ten strings:
+        Return a string describing the class of the operand.
+
+        The returned value is one of the following ten strings:
 
             * '-Infinity', indicating that the operand is negative infinity.
-            * '-Normal', indicating that the operand is a negative normal number.
-            * '-Subnormal', indicating that the operand is negative and subnormal.
+            * '-Normal', indicating that the operand is a negative normal
+              number.
+            * '-Subnormal', indicating that the operand is negative and
+              subnormal.
             * '-Zero', indicating that the operand is a negative zero.
             * '+Zero', indicating that the operand is a positive zero.
-            * '+Subnormal', indicating that the operand is positive and subnormal.
-            * '+Normal', indicating that the operand is a positive normal number.
+            * '+Subnormal', indicating that the operand is positive and
+              subnormal.
+            * '+Normal', indicating that the operand is a positive normal
+              number.
             * '+Infinity', indicating that the operand is positive infinity.
-            * 'NaN', indicating that the operand is a quiet NaN (Not a Number).
+            * 'NaN', indicating that the operand is a quiet NaN (Not a
+              Number).
             * 'sNaN', indicating that the operand is a signaling NaN.
         """
         ...
     def radix(self) -> Decimal:
         """
-        Return Decimal(10), the radix (base) in which the Decimal class does
-        all its arithmetic. Included for compatibility with the specification.
+        Return Decimal(10).
+
+        This is the radix (base) in which the Decimal class does all its
+        arithmetic. Included for compatibility with the specification.
         """
         ...
     def rotate(self, other: _Decimal, context: Context | None = None) -> Decimal:
         """
-        Return the result of rotating the digits of the first operand by an amount
-        specified by the second operand.  The second operand must be an integer in
-        the range -precision through precision. The absolute value of the second
-        operand gives the number of places to rotate. If the second operand is
-        positive then rotation is to the left; otherwise rotation is to the right.
-        The coefficient of the first operand is padded on the left with zeros to
-        length precision if necessary. The sign and exponent of the first operand are
-        unchanged.
+        Returns a rotated copy of self's digits, value-of-other times.
+
+        The second operand must be an integer in the range -precision
+        through precision.  The absolute value of the second operand gives
+        the number of places to rotate.  If the second operand is positive
+        then rotation is to the left; otherwise rotation is to the right.
+        The coefficient of the first operand is padded on the left with
+        zeros to length precision if necessary.  The sign and exponent of
+        the first operand are unchanged.
         """
         ...
     def scaleb(self, other: _Decimal, context: Context | None = None) -> Decimal:
         """
-        Return the first operand with the exponent adjusted the second.  Equivalently,
-        return the first operand multiplied by 10**other. The second operand must be
-        an integer.
+        Return the first operand with the exponent adjusted the second.
+
+        Equivalently, return the first operand multiplied by 10**other. The
+        second operand must be an integer.
         """
         ...
     def shift(self, other: _Decimal, context: Context | None = None) -> Decimal:
         """
-        Return the result of shifting the digits of the first operand by an amount
-        specified by the second operand.  The second operand must be an integer in
-        the range -precision through precision. The absolute value of the second
-        operand gives the number of places to shift. If the second operand is
-        positive, then the shift is to the left; otherwise the shift is to the
-        right. Digits shifted into the coefficient are zeros. The sign and exponent
-        of the first operand are unchanged.
+        Returns a shifted copy of self's digits, value-of-other times.
+
+        The second operand must be an integer in the range -precision
+        through precision.  The absolute value of the second operand gives
+        the number of places to shift.  If the second operand is positive,
+        then the shift is to the left; otherwise the shift is to the right.
+        Digits shifted into the coefficient are zeros.  The sign and
+        exponent of the first operand are unchanged.
         """
         ...
-    def __reduce__(self) -> tuple[type[Self], tuple[str]]: ...
+    def __reduce__(self) -> tuple[type[Self], tuple[str]]:
+        """Return state information for pickling."""
+        ...
     def __copy__(self) -> Self: ...
     def __deepcopy__(self, memo: Any, /) -> Self: ...
-    def __format__(self, specifier: str, context: Context | None = None, /) -> str: ...
+    def __format__(self, specifier: str, context: Context | None = None, /) -> str:
+        """Formats the Decimal according to format_spec."""
+        ...
 
 @disjoint_base
 class Context:
@@ -655,27 +703,34 @@ class Context:
     __hash__: ClassVar[None]  # type: ignore[assignment]
     def Etiny(self) -> int:
         """
-        Return a value equal to Emin - prec + 1, which is the minimum exponent value
-        for subnormal results.  When underflow occurs, the exponent is set to Etiny.
+        Return a value equal to Emin - prec + 1.
+
+        This is the minimum exponent value for subnormal results.  When
+        underflow occurs, the exponent is set to Etiny.
         """
         ...
     def Etop(self) -> int:
         """
-        Return a value equal to Emax - prec + 1.  This is the maximum exponent
-        if the _clamp field of the context is set to 1 (IEEE clamp mode).  Etop()
-        must not be negative.
+        Return a value equal to Emax - prec + 1.
+
+        This is the maximum exponent if the _clamp field of the context is
+        set to 1 (IEEE clamp mode).  Etop() must not be negative.
         """
         ...
     def create_decimal(self, num: _DecimalNew = "0", /) -> Decimal:
         """
-        Create a new Decimal instance from num, using self as the context. Unlike the
-        Decimal constructor, this function observes the context limits.
+        Create a new Decimal instance from num, using self as the context.
+
+        Unlike the Decimal constructor, this function observes the context
+        limits.
         """
         ...
     def create_decimal_from_float(self, f: float, /) -> Decimal:
         """
-        Create a new Decimal instance from float f.  Unlike the Decimal.from_float()
-        class method, this function observes the context limits.
+        Create a new Decimal instance from float f.
+
+        Unlike the Decimal.from_float() class method, this function observes
+        the context limits.
         """
         ...
     def abs(self, x: _Decimal, /) -> Decimal:
@@ -875,8 +930,9 @@ class Context:
         ...
     def minus(self, x: _Decimal, /) -> Decimal:
         """
-        Minus corresponds to the unary prefix minus operator in Python, but applies
-        the context to the result.
+        Minus corresponds to unary prefix minus in Python.
+
+        This operation applies the context to the result.
         """
         ...
     def multiply(self, x: _Decimal, y: _Decimal, /) -> Decimal:
@@ -899,25 +955,29 @@ class Context:
         ...
     def plus(self, x: _Decimal, /) -> Decimal:
         """
-        Plus corresponds to the unary prefix plus operator in Python, but applies
-        the context to the result.
+        Plus corresponds to the unary prefix plus operator in Python.
+
+        This operation applies the context to the result.
         """
         ...
     def power(self, a: _Decimal, b: _Decimal, modulo: _Decimal | None = None) -> Decimal:
         """
-        Compute a**b. If 'a' is negative, then 'b' must be integral. The result
-        will be inexact unless 'a' is integral and the result is finite and can
-        be expressed exactly in 'precision' digits.  In the Python version the
-        result is always correctly rounded, in the C version the result is almost
-        always correctly rounded.
+        Compute a**b.
+
+        If 'a' is negative, then 'b' must be integral. The result will be
+        inexact unless 'a' is integral and the result is finite and can be
+        expressed exactly in 'precision' digits.  In the Python version the
+        result is always correctly rounded, in the C version the result is
+        almost always correctly rounded.
 
-        If modulo is given, compute (a**b) % modulo. The following restrictions
-        hold:
+        If modulo is given, compute (a**b) % modulo. The following
+        restrictions hold:
 
             * all three arguments must be integral
             * 'b' must be nonnegative
             * at least one of 'a' or 'b' must be nonzero
-            * modulo must be nonzero and less than 10**prec in absolute value
+            * modulo must be nonzero and less than 10**prec in absolute
+              value
         """
         ...
     def quantize(self, x: _Decimal, y: _Decimal, /) -> Decimal:
@@ -928,14 +988,18 @@ class Context:
         ...
     def remainder(self, x: _Decimal, y: _Decimal, /) -> Decimal:
         """
-        Return the remainder from integer division.  The sign of the result,
-        if non-zero, is the same as that of the original dividend.
+        Return the remainder from integer division.
+
+        The sign of the result, if non-zero, is the same as that of the
+        original dividend.
         """
         ...
     def remainder_near(self, x: _Decimal, y: _Decimal, /) -> Decimal:
         """
-        Return x - y * n, where n is the integer nearest the exact value of x / y
-        (if the result is 0 then its sign will be the sign of x).
+        Return x - y * n.
+
+        Here n is the integer nearest the exact value of x / y (if the
+        result is 0 then its sign will be the sign of x).
         """
         ...
     def rotate(self, x: _Decimal, y: _Decimal, /) -> Decimal: