numerary.types package reference

Experimental

This package is an attempt to ease compatibility between Python’s numbers and types. If that sounds like it shouldn’t be a thing, you won’t get any argument out of me. Anyhoo, this package should be considered experimental. I am working toward stability as quickly as possible, but be warned that future release may introduce incompatibilities or remove this package altogether. Feedback, suggestions, and contributions are desperately appreciated.

RationalLike

Bases: SupportsAbs[_T_co], SupportsFloat, SupportsNumeratorDenominator, SupportsRealOps[_T_co], SupportsComplexOps[_T_co], SupportsComplexPow, Protocol, Generic[_T_co]

A caching ABC that defines a core set of operations for interacting with rationals. It is a composition of:

• SupportsAbs
• SupportsFloat
• SupportsNumeratorDenominator
• SupportsRealOps
• SupportsComplexOps
• SupportsComplexPow
• a __hash__ method

Basically:

from typing TypeVar, runtime_checkable
from beartype.typing import Protocol
from numerary.types import CachingProtocolMeta, Supports…
T_co = TypeVar("T_co", covariant=True)

@runtime_checkable
class RationalLike(
  SupportsAbs[T_co],
  SupportsFloat,
  SupportsNumeratorDenominator,
  SupportsRealOps[T_co],
  SupportsComplexOps[T_co],
  SupportsComplexPow[T_co],
  Protocol[T_co],
  metaclass=CachingProtocolMeta,
):
  @abstractmethod
  def __hash__(self) -> int:
    pass

This is intended as a practically useful, but incomplete list. To enforce equivalence to numbers.Rational, one would also need:

• SupportsComplex
• SupportsConjugate
• SupportsRealImag
• SupportsRound
• SupportsTrunc
• SupportsFloorCeil
• SupportsDivmod

Source code in numerary/types.py

@runtime_checkable
class RationalLike(
    SupportsAbs[_T_co],
    SupportsFloat,
    SupportsNumeratorDenominator,
    SupportsRealOps[_T_co],
    SupportsComplexOps[_T_co],
    SupportsComplexPow,
    Protocol,
    Generic[_T_co],
    metaclass=CachingProtocolMeta,
):
    r"""
    A caching ABC that defines a core set of operations for interacting with rationals.
    It is a composition of:

    * [``SupportsAbs``][numerary.types.SupportsAbs]
    * [``SupportsFloat``][numerary.types.SupportsFloat]
    * [``SupportsNumeratorDenominator``][numerary.types.SupportsNumeratorDenominator]
    * [``SupportsRealOps``][numerary.types.SupportsRealOps]
    * [``SupportsComplexOps``][numerary.types.SupportsComplexOps]
    * [``SupportsComplexPow``][numerary.types.SupportsComplexPow]
    * a ``__hash__`` method

    Basically:

    ``` python
    from typing TypeVar, runtime_checkable
    from beartype.typing import Protocol
    from numerary.types import CachingProtocolMeta, Supports…
    T_co = TypeVar("T_co", covariant=True)

    @runtime_checkable
    class RationalLike(
      SupportsAbs[T_co],
      SupportsFloat,
      SupportsNumeratorDenominator,
      SupportsRealOps[T_co],
      SupportsComplexOps[T_co],
      SupportsComplexPow[T_co],
      Protocol[T_co],
      metaclass=CachingProtocolMeta,
    ):
      @abstractmethod
      def __hash__(self) -> int:
        pass
    ```

    This is intended as a practically useful, but incomplete list. To enforce
    equivalence to ``#!python numbers.Rational``, one would also need:

    * [``SupportsComplex``][numerary.types.SupportsComplex]
    * [``SupportsConjugate``][numerary.types.SupportsConjugate]
    * [``SupportsRealImag``][numerary.types.SupportsRealImag]
    * [``SupportsRound``][numerary.types.SupportsRound]
    * [``SupportsTrunc``][numerary.types.SupportsTrunc]
    * [``SupportsFloorCeil``][numerary.types.SupportsFloorCeil]
    * [``SupportsDivmod``][numerary.types.SupportsDivmod]
    """

    # Must be able to instantiate it
    @abstractmethod
    def __init__(self, *args: Any, **kw: Any):
        pass

    @abstractmethod
    def __hash__(self) -> int:
        pass

RationalLikeMethods

Bases: SupportsAbs[_T_co], SupportsFloat, SupportsNumeratorDenominatorMethods, SupportsRealOps[_T_co], SupportsComplexOps[_T_co], SupportsComplexPow, Protocol, Generic[_T_co]

A caching ABC that defines a core set of operations for interacting with rationals. It is identical to RationalLike with one important exception. Instead of SupportsNumeratorDenominator, this protocol provides SupportsNumeratorDenominatorMethods.

Basically:

from typing TypeVar, runtime_checkable
from beartype.typing import Protocol
from numerary.types import CachingProtocolMeta, Supports…
T_co = TypeVar("T_co", covariant=True)

@runtime_checkable
class RationalLikeMethods(
  SupportsAbs[T_co],
  SupportsFloat,
  SupportsNumeratorDenominatorMethods,
  SupportsRealOps[T_co],
  SupportsComplexOps[T_co],
  SupportsComplexPow[T_co],
  Protocol[T_co],
  metaclass=CachingProtocolMeta,
):
  @abstractmethod
  def __hash__(self) -> int:
    pass

This is probably not very useful on its own, but is important to the construction of RationalLikeMixedU and RationalLikeMixedT.

See also the numerator and denominator helper functions.

Source code in numerary/types.py

@runtime_checkable
class RationalLikeMethods(
    SupportsAbs[_T_co],
    SupportsFloat,
    SupportsNumeratorDenominatorMethods,
    SupportsRealOps[_T_co],
    SupportsComplexOps[_T_co],
    SupportsComplexPow,
    Protocol,
    Generic[_T_co],
    metaclass=CachingProtocolMeta,
):
    r"""
    A caching ABC that defines a core set of operations for interacting with rationals.
    It is identical to [``RationalLike``][numerary.types.RationalLike] with one
    important exception. Instead of
    [``SupportsNumeratorDenominator``][numerary.types.SupportsNumeratorDenominator],
    this protocol provides
    [``SupportsNumeratorDenominatorMethods``][numerary.types.SupportsNumeratorDenominatorMethods].

    Basically:

    ``` python
    from typing TypeVar, runtime_checkable
    from beartype.typing import Protocol
    from numerary.types import CachingProtocolMeta, Supports…
    T_co = TypeVar("T_co", covariant=True)

    @runtime_checkable
    class RationalLikeMethods(
      SupportsAbs[T_co],
      SupportsFloat,
      SupportsNumeratorDenominatorMethods,
      SupportsRealOps[T_co],
      SupportsComplexOps[T_co],
      SupportsComplexPow[T_co],
      Protocol[T_co],
      metaclass=CachingProtocolMeta,
    ):
      @abstractmethod
      def __hash__(self) -> int:
        pass
    ```

    This is probably not very useful on its own, but is important to the construction of
    [``RationalLikeMixedU``][numerary.types.RationalLikeMixedU] and
    [``RationalLikeMixedT``][numerary.types.RationalLikeMixedT].

    See also the [``numerator``][numerary.types.numerator] and
    [``denominator``][numerary.types.denominator] helper functions.
    """

    # Must be able to instantiate it
    @abstractmethod
    def __init__(self, *args: Any, **kw: Any):
        pass

    @abstractmethod
    def __hash__(self) -> int:
        pass

SupportsAbs

Bases: _SupportsAbs[_T_co], Protocol, Generic[_T_co]

A derivative of beartype.typing.SupportsAbs with an override-able cache.

Source code in numerary/types.py

@runtime_checkable
class SupportsAbs(
    _SupportsAbs[_T_co],
    Protocol,
    Generic[_T_co],
    metaclass=CachingProtocolMeta,
):
    r"""
    A derivative of ``beartype.typing.SupportsAbs`` with an override-able cache.
    """

SupportsComplex

Bases: _SupportsComplex, Protocol

A derivative of beartype.typing.SupportsComplex with an override-able cache.

Source code in numerary/types.py

@runtime_checkable
class SupportsComplex(
    _SupportsComplex,
    Protocol,
    metaclass=CachingProtocolMeta,
):
    r"""
    A derivative of ``beartype.typing.SupportsComplex`` with an override-able cache.
    """

SupportsFloat

Bases: _SupportsFloat, Protocol

A derivative of beartype.typing.SupportsFloat with an override-able cache.

Source code in numerary/types.py

@runtime_checkable
class SupportsFloat(
    _SupportsFloat,
    Protocol,
    metaclass=CachingProtocolMeta,
):
    r"""
    A derivative of ``beartype.typing.SupportsFloat`` with an override-able cache.
    """

SupportsInt

Bases: _SupportsInt, Protocol

A derivative of beartype.typing.SupportsInt with an override-able cache.

Source code in numerary/types.py

@runtime_checkable
class SupportsInt(
    _SupportsInt,
    Protocol,
    metaclass=CachingProtocolMeta,
):
    r"""
    A derivative of ``beartype.typing.SupportsInt`` with an override-able cache.
    """

SupportsIndex

Bases: _SupportsIndex, Protocol

A derivative of beartype.typing.SupportsIndex with an override-able cache.

Source code in numerary/types.py

@runtime_checkable
class SupportsIndex(
    _SupportsIndex,
    Protocol,
    metaclass=CachingProtocolMeta,
):
    r"""
    A derivative of ``beartype.typing.SupportsIndex`` with an override-able cache.
    """

SupportsRound

Bases: _SupportsRound[_T_co], Protocol, Generic[_T_co]

A derivative of beartype.typing.SupportsRound with an override-able cache.

Source code in numerary/types.py

@runtime_checkable
class SupportsRound(
    _SupportsRound[_T_co],
    Protocol,
    Generic[_T_co],
    metaclass=CachingProtocolMeta,
):
    r"""
    A derivative of ``beartype.typing.SupportsRound`` with an override-able cache.
    """

SupportsConjugate

Bases: _SupportsConjugate, Protocol

A caching ABC defining the conjugate method.

(_SupportsConjugate is the raw, non-caching version that defines the actual methods.)

>>> from typing import TypeVar
>>> from numerary.types import SupportsConjugate
>>> MyConjugateT = TypeVar("MyConjugateT", bound=SupportsConjugate)

>>> def conjugate_my_thing(arg: MyConjugateT) -> MyConjugateT:
...   assert isinstance(arg, SupportsConjugate)
...   return arg.conjugate()

>>> conjugate_my_thing(3)
3

>>> from decimal import Decimal
>>> conjugate_my_thing(Decimal(2.5))
Decimal('2.5')

>>> import sympy
>>> conjugate_my_thing(sympy.Float(3.5))
3.5
>>> type(_)
<class 'sympy.core.numbers.Float'>

>>> # error: Value of type variable "MyConjugateT" of "conjugate_my_thing" cannot be "str"
>>> conjugate_my_thing("not-a-number")  # type: ignore [type-var]
Traceback (most recent call last):
  ...
AssertionError

Source code in numerary/types.py

@runtime_checkable
class SupportsConjugate(
    _SupportsConjugate,
    Protocol,
    metaclass=CachingProtocolMeta,
):
    r"""
    A caching ABC defining the [``conjugate``
    method](https://docs.python.org/3/library/numbers.html#numbers.Complex.conjugate).

    ([``_SupportsConjugate``][numerary.types._SupportsConjugate] is the raw, non-caching
    version that defines the actual methods.)

    ``` python
    >>> from typing import TypeVar
    >>> from numerary.types import SupportsConjugate
    >>> MyConjugateT = TypeVar("MyConjugateT", bound=SupportsConjugate)

    >>> def conjugate_my_thing(arg: MyConjugateT) -> MyConjugateT:
    ...   assert isinstance(arg, SupportsConjugate)
    ...   return arg.conjugate()

    >>> conjugate_my_thing(3)
    3

    >>> from decimal import Decimal
    >>> conjugate_my_thing(Decimal(2.5))
    Decimal('2.5')

    >>> import sympy
    >>> conjugate_my_thing(sympy.Float(3.5))
    3.5
    >>> type(_)
    <class 'sympy.core.numbers.Float'>

    >>> # error: Value of type variable "MyConjugateT" of "conjugate_my_thing" cannot be "str"
    >>> conjugate_my_thing("not-a-number")  # type: ignore [type-var]
    Traceback (most recent call last):
      ...
    AssertionError

    ```
    """

SupportsRealImag

Bases: _SupportsRealImag, Protocol

A caching ABC defining the real and imag properties.

(_SupportsRealImag is the raw, non-caching version that defines the actual methods.)

>>> from typing import Any, Tuple, TypeVar
>>> from numerary.types import SupportsRealImag, real, imag
>>> MyRealImagT = TypeVar("MyRealImagT", bound=SupportsRealImag)

>>> def real_imag_my_thing(arg: MyRealImagT) -> Tuple[Any, Any]:
...   assert isinstance(arg, SupportsRealImag)
...   return (real(arg), imag(arg))

>>> real_imag_my_thing(3)
(3, 0)

>>> from decimal import Decimal
>>> real_imag_my_thing(Decimal(2.5))
(Decimal('2.5'), Decimal('0'))

>>> # error: Value of type variable "MyRealImagT" of "real_imag_my_thing" cannot be "str"
>>> real_imag_my_thing("not-a-number")  # type: ignore [type-var]
Traceback (most recent call last):
  ...
AssertionError

Source code in numerary/types.py

@runtime_checkable
class SupportsRealImag(
    _SupportsRealImag,
    Protocol,
    metaclass=CachingProtocolMeta,
):
    r"""
    A caching ABC defining the
    [``real``](https://docs.python.org/3/library/numbers.html#numbers.Complex.real) and
    [``imag``](https://docs.python.org/3/library/numbers.html#numbers.Complex.imag)
    properties.

    ([``_SupportsRealImag``][numerary.types._SupportsRealImag] is
    the raw, non-caching version that defines the actual methods.)

    ``` python
    >>> from typing import Any, Tuple, TypeVar
    >>> from numerary.types import SupportsRealImag, real, imag
    >>> MyRealImagT = TypeVar("MyRealImagT", bound=SupportsRealImag)

    >>> def real_imag_my_thing(arg: MyRealImagT) -> Tuple[Any, Any]:
    ...   assert isinstance(arg, SupportsRealImag)
    ...   return (real(arg), imag(arg))

    >>> real_imag_my_thing(3)
    (3, 0)

    >>> from decimal import Decimal
    >>> real_imag_my_thing(Decimal(2.5))
    (Decimal('2.5'), Decimal('0'))

    >>> # error: Value of type variable "MyRealImagT" of "real_imag_my_thing" cannot be "str"
    >>> real_imag_my_thing("not-a-number")  # type: ignore [type-var]
    Traceback (most recent call last):
      ...
    AssertionError

    ```
    """

SupportsRealImagAsMethod

Bases: _SupportsRealImagAsMethod, Protocol

A caching ABC defining the as_real_imag method that returns a 2-tuple.

(_SupportsRealImagAsMethod is the raw, non-caching version that defines the actual methods.)

See also the real and imag helper functions.

>>> from typing import Any, Tuple, TypeVar
>>> from numerary.types import SupportsRealImagAsMethod, real, imag
>>> MyRealImagAsMethodT = TypeVar("MyRealImagAsMethodT", bound=SupportsRealImagAsMethod)

>>> def as_real_imag_my_thing(arg: MyRealImagAsMethodT) -> Tuple[Any, Any]:
...   assert isinstance(arg, SupportsRealImagAsMethod)
...   return (real(arg), imag(arg))

>>> as_real_imag_my_thing(sympy.Float(3.5))
(3.5, 0)
>>> tuple(type(i) for i in _)
(<class 'sympy.core.numbers.Float'>, <class 'sympy.core.numbers.Zero'>)

>>> # error: Value of type variable "MyRealImagAsMethodT" of "as_real_imag_my_thing" cannot be "str"
>>> as_real_imag_my_thing("not-a-number")  # type: ignore [type-var]
Traceback (most recent call last):
  ...
AssertionError

Source code in numerary/types.py

@runtime_checkable
class SupportsRealImagAsMethod(
    _SupportsRealImagAsMethod,
    Protocol,
    metaclass=CachingProtocolMeta,
):
    r"""
    A caching ABC defining the ``#!python as_real_imag`` method that returns a 2-tuple.

    ([``_SupportsRealImagAsMethod``][numerary.types._SupportsRealImagAsMethod]
    is the raw, non-caching version that defines the actual methods.)

    See also the [``real``][numerary.types.real] and [``imag``][numerary.types.imag]
    helper functions.

    ``` python
    >>> from typing import Any, Tuple, TypeVar
    >>> from numerary.types import SupportsRealImagAsMethod, real, imag
    >>> MyRealImagAsMethodT = TypeVar("MyRealImagAsMethodT", bound=SupportsRealImagAsMethod)

    >>> def as_real_imag_my_thing(arg: MyRealImagAsMethodT) -> Tuple[Any, Any]:
    ...   assert isinstance(arg, SupportsRealImagAsMethod)
    ...   return (real(arg), imag(arg))

    >>> as_real_imag_my_thing(sympy.Float(3.5))
    (3.5, 0)
    >>> tuple(type(i) for i in _)
    (<class 'sympy.core.numbers.Float'>, <class 'sympy.core.numbers.Zero'>)

    >>> # error: Value of type variable "MyRealImagAsMethodT" of "as_real_imag_my_thing" cannot be "str"
    >>> as_real_imag_my_thing("not-a-number")  # type: ignore [type-var]
    Traceback (most recent call last):
      ...
    AssertionError

    ```
    """

SupportsTrunc

Bases: _SupportsTrunc, Protocol

A caching ABC defining the __trunc__ method.

See also the __trunc__ helper function.

(_SupportsTrunc is the raw, non-caching version that defines the actual methods.)

>>> from typing import Any, Tuple, TypeVar
>>> from numerary.types import SupportsTrunc, __trunc__
>>> MyTruncT = TypeVar("MyTruncT", bound=SupportsTrunc)

>>> def trunc_my_thing(arg: MyTruncT) -> Tuple[Any, Any]:
...   assert isinstance(arg, SupportsTrunc)
...   return __trunc__(arg)

>>> trunc_my_thing(3)
3

>>> from decimal import Decimal
>>> trunc_my_thing(Decimal(2.5))
2

>>> import sympy
>>> trunc_my_thing(sympy.Float(3.5))
3
>>> type(_)
<class 'sympy.core.numbers.Integer'>

>>> # error: Value of type variable "MyTruncT" of "trunc_my_thing" cannot be "str"
>>> trunc_my_thing("not-a-number")  # type: ignore [type-var]
Traceback (most recent call last):
  ...
AssertionError

Source code in numerary/types.py

@runtime_checkable
class SupportsTrunc(
    _SupportsTrunc,
    Protocol,
    metaclass=CachingProtocolMeta,
):
    r"""
    A caching ABC defining the [``__trunc__``
    method](https://docs.python.org/3/reference/datamodel.html#object.__trunc__).

    See also the [``__trunc__`` helper function][numerary.types.__trunc__].

    ([``_SupportsTrunc``][numerary.types._SupportsTrunc] is the raw, non-caching version
    that defines the actual methods.)

    ``` python
    >>> from typing import Any, Tuple, TypeVar
    >>> from numerary.types import SupportsTrunc, __trunc__
    >>> MyTruncT = TypeVar("MyTruncT", bound=SupportsTrunc)

    >>> def trunc_my_thing(arg: MyTruncT) -> Tuple[Any, Any]:
    ...   assert isinstance(arg, SupportsTrunc)
    ...   return __trunc__(arg)

    >>> trunc_my_thing(3)
    3

    >>> from decimal import Decimal
    >>> trunc_my_thing(Decimal(2.5))
    2

    >>> import sympy
    >>> trunc_my_thing(sympy.Float(3.5))
    3
    >>> type(_)
    <class 'sympy.core.numbers.Integer'>

    >>> # error: Value of type variable "MyTruncT" of "trunc_my_thing" cannot be "str"
    >>> trunc_my_thing("not-a-number")  # type: ignore [type-var]
    Traceback (most recent call last):
      ...
    AssertionError

    ```
    """

SupportsFloorCeil

Bases: _SupportsFloorCeil, Protocol

A caching ABC defining the __floor__. and __ceil__ methods.

(_SupportsFloorCeil is the raw, non-caching version that defines the actual methods.)

Note

This is of limited value for Python versions prior to 3.9, since float.__floor__ and float.__ceil__ were not defined. If support for those environments is important, consider using SupportsFloat instead.

See also the __floor__ and __ceil__ helper functions.

>>> from typing import Any, Tuple, TypeVar
>>> from numerary.types import SupportsFloorCeil, __ceil__, __floor__
>>> MyFloorCeilT = TypeVar("MyFloorCeilT", bound=SupportsFloorCeil)

>>> def floor_ceil_my_thing(arg: MyFloorCeilT) -> Tuple[int, int]:
...   assert isinstance(arg, SupportsFloorCeil)
...   return __floor__(arg), __ceil__(arg)

>>> floor_ceil_my_thing(3)
(3, 3)

>>> from decimal import Decimal
>>> floor_ceil_my_thing(Decimal(2.5))
(2, 3)

>>> import sympy
>>> floor_ceil_my_thing(sympy.Float(3.5))
(3, 4)
>>> tuple(type(i) for i in _)
(<class 'sympy.core.numbers.Integer'>, <class 'sympy.core.numbers.Integer'>)

>>> # error: Value of type variable "MyFloorCeilT" of "floor_ceil_my_thing" cannot be "str"
>>> floor_ceil_my_thing("not-a-number")  # type: ignore [type-var]
Traceback (most recent call last):
  ...
AssertionError

Source code in numerary/types.py

@runtime_checkable
class SupportsFloorCeil(
    _SupportsFloorCeil,
    Protocol,
    metaclass=CachingProtocolMeta,
):
    r"""
    A caching ABC defining the
    [``__floor__``](https://docs.python.org/3/reference/datamodel.html#object.__floor__).
    and
    [``__ceil__``](https://docs.python.org/3/reference/datamodel.html#object.__ceil__)
    methods.

    ([``_SupportsFloorCeil``][numerary.types._SupportsFloorCeil] is the raw, non-caching
    version that defines the actual methods.)

    !!! note

        This is of limited value for Python versions prior to 3.9, since ``#!python
        float.__floor__`` and ``#!python float.__ceil__`` were not defined. If support
        for those environments is important, consider using
        [``SupportsFloat``][numerary.types.SupportsFloat] instead.

        See also the [``__floor__``][numerary.types.__floor__] and
        [``__ceil__``][numerary.types.__ceil__] helper functions.

    ``` python
    >>> from typing import Any, Tuple, TypeVar
    >>> from numerary.types import SupportsFloorCeil, __ceil__, __floor__
    >>> MyFloorCeilT = TypeVar("MyFloorCeilT", bound=SupportsFloorCeil)

    >>> def floor_ceil_my_thing(arg: MyFloorCeilT) -> Tuple[int, int]:
    ...   assert isinstance(arg, SupportsFloorCeil)
    ...   return __floor__(arg), __ceil__(arg)

    >>> floor_ceil_my_thing(3)
    (3, 3)

    >>> from decimal import Decimal
    >>> floor_ceil_my_thing(Decimal(2.5))
    (2, 3)

    >>> import sympy
    >>> floor_ceil_my_thing(sympy.Float(3.5))
    (3, 4)
    >>> tuple(type(i) for i in _)
    (<class 'sympy.core.numbers.Integer'>, <class 'sympy.core.numbers.Integer'>)

    >>> # error: Value of type variable "MyFloorCeilT" of "floor_ceil_my_thing" cannot be "str"
    >>> floor_ceil_my_thing("not-a-number")  # type: ignore [type-var]
    Traceback (most recent call last):
      ...
    AssertionError

    ```
    """

SupportsDivmod

Bases: _SupportsDivmod[_T_co], Protocol, Generic[_T_co]

A caching ABC defining the __divmod__ and __rdivmod__ methods. Each returns a 2-tuple of covariants.

(_SupportsDivmod is the raw, non-caching version that defines the actual methods.)

>>> from typing import Any, Tuple, TypeVar
>>> from numerary.types import SupportsDivmod
>>> MyDivmodT = TypeVar("MyDivmodT", bound=SupportsDivmod)

>>> def divmod_my_thing(arg: MyDivmodT, other: Any) -> Tuple[MyDivmodT, MyDivmodT]:
...   assert isinstance(arg, SupportsDivmod)
...   return divmod(arg, other)

>>> divmod_my_thing(2, 1)
(2, 0)

>>> from decimal import Decimal
>>> divmod_my_thing(Decimal(2.5), Decimal(1.5))
(Decimal('1'), Decimal('1.0'))

>>> import sympy
>>> divmod_my_thing(sympy.Float(3.5), sympy.Float(1.5))
(2, 0.5)
>>> tuple(type(i) for i in _)
(<class 'sympy.core.numbers.Integer'>, <class 'sympy.core.numbers.Float'>)

>>> # error: Value of type variable "MyDivmodT" of "divmod_my_thing" cannot be "str"
>>> divmod_my_thing("not-a-number", "still-not-a-number")  # type: ignore [type-var]
Traceback (most recent call last):
  ...
AssertionError

Source code in numerary/types.py

@runtime_checkable
class SupportsDivmod(
    _SupportsDivmod[_T_co],
    Protocol,
    Generic[_T_co],
    metaclass=CachingProtocolMeta,
):
    r"""
    A caching ABC defining the
    [``__divmod__``](https://docs.python.org/3/reference/datamodel.html#object.__divmod__)
    and
    [``__rdivmod__``](https://docs.python.org/3/reference/datamodel.html#object.__rdivmod__)
    methods. Each returns a 2-tuple of covariants.

    ([``_SupportsDivmod``][numerary.types._SupportsDivmod] is the raw, non-caching
    version that defines the actual methods.)

    ``` python
    >>> from typing import Any, Tuple, TypeVar
    >>> from numerary.types import SupportsDivmod
    >>> MyDivmodT = TypeVar("MyDivmodT", bound=SupportsDivmod)

    >>> def divmod_my_thing(arg: MyDivmodT, other: Any) -> Tuple[MyDivmodT, MyDivmodT]:
    ...   assert isinstance(arg, SupportsDivmod)
    ...   return divmod(arg, other)

    >>> divmod_my_thing(2, 1)
    (2, 0)

    >>> from decimal import Decimal
    >>> divmod_my_thing(Decimal(2.5), Decimal(1.5))
    (Decimal('1'), Decimal('1.0'))

    >>> import sympy
    >>> divmod_my_thing(sympy.Float(3.5), sympy.Float(1.5))
    (2, 0.5)
    >>> tuple(type(i) for i in _)
    (<class 'sympy.core.numbers.Integer'>, <class 'sympy.core.numbers.Float'>)

    >>> # error: Value of type variable "MyDivmodT" of "divmod_my_thing" cannot be "str"
    >>> divmod_my_thing("not-a-number", "still-not-a-number")  # type: ignore [type-var]
    Traceback (most recent call last):
      ...
    AssertionError

    ```
    """

SupportsNumeratorDenominator

Bases: _SupportsNumeratorDenominator, Protocol

A caching ABC defining the numerator and denominator properties.

(_SupportsNumeratorDenominator is the raw, non-caching version that defines the actual properties.)

>>> from typing import Any, Tuple, TypeVar
>>> from numerary.types import SupportsNumeratorDenominator, denominator, numerator
>>> MyNumDenomT = TypeVar("MyNumDenomT", bound=SupportsNumeratorDenominator)

>>> def num_denom_my_thing(arg: MyNumDenomT) -> Tuple[int, int]:
...   assert isinstance(arg, SupportsNumeratorDenominator)
...   return numerator(arg), denominator(arg)

>>> num_denom_my_thing(3)
(3, 1)

>>> from fractions import Fraction
>>> num_denom_my_thing(Fraction(2, 3))
(2, 3)

>>> import sympy
>>> num_denom_my_thing(sympy.Rational(3, 4))
(3, 4)
>>> tuple(type(i) for i in _)
(<class 'int'>, <class 'int'>)

>>> # error: Value of type variable "MyNumDenomT" of "num_denom_my_thing" cannot be "str"
>>> num_denom_my_thing("not-a-number")  # type: ignore [type-var]
Traceback (most recent call last):
  ...
AssertionError

Source code in numerary/types.py

@runtime_checkable
class SupportsNumeratorDenominator(
    _SupportsNumeratorDenominator,
    Protocol,
    metaclass=CachingProtocolMeta,
):
    r"""
    A caching ABC defining the
    [``numerator``](https://docs.python.org/3/library/numbers.html#numbers.Rational.numerator)
    and
    [``denominator``](https://docs.python.org/3/library/numbers.html#numbers.Rational.denominator)
    properties.

    ([``_SupportsNumeratorDenominator``][numerary.types._SupportsNumeratorDenominator]
    is the raw, non-caching version that defines the actual properties.)

    ``` python
    >>> from typing import Any, Tuple, TypeVar
    >>> from numerary.types import SupportsNumeratorDenominator, denominator, numerator
    >>> MyNumDenomT = TypeVar("MyNumDenomT", bound=SupportsNumeratorDenominator)

    >>> def num_denom_my_thing(arg: MyNumDenomT) -> Tuple[int, int]:
    ...   assert isinstance(arg, SupportsNumeratorDenominator)
    ...   return numerator(arg), denominator(arg)

    >>> num_denom_my_thing(3)
    (3, 1)

    >>> from fractions import Fraction
    >>> num_denom_my_thing(Fraction(2, 3))
    (2, 3)

    >>> import sympy
    >>> num_denom_my_thing(sympy.Rational(3, 4))
    (3, 4)
    >>> tuple(type(i) for i in _)
    (<class 'int'>, <class 'int'>)

    >>> # error: Value of type variable "MyNumDenomT" of "num_denom_my_thing" cannot be "str"
    >>> num_denom_my_thing("not-a-number")  # type: ignore [type-var]
    Traceback (most recent call last):
      ...
    AssertionError

    ```
    """

SupportsNumeratorDenominatorMethods

Bases: _SupportsNumeratorDenominatorMethods, Protocol

A caching ABC defining numerator and denominator methods. Each returns a SupportsInt.

(_SupportsNumeratorDenominatorMethods is the raw, non-caching version that defines the actual methods.)

See also the numerator and denominator helper functions.

Source code in numerary/types.py

@runtime_checkable
class SupportsNumeratorDenominatorMethods(
    _SupportsNumeratorDenominatorMethods,
    Protocol,
    metaclass=CachingProtocolMeta,
):
    r"""
    A caching ABC defining ``#!python numerator`` and ``#!python denominator`` methods.
    Each returns a [``SupportsInt``][numerary.types.SupportsInt].

    ([``_SupportsNumeratorDenominatorMethods``][numerary.types._SupportsNumeratorDenominatorMethods]
    is the raw, non-caching version that defines the actual methods.)

    See also the [``numerator``][numerary.types.numerator] and
    [``denominator``][numerary.types.denominator] helper functions.
    """

SupportsComplexOps

Bases: _SupportsComplexOps[_T_co], Protocol, Generic[_T_co]

A caching ABC defining the Complex operator methods with covariant return values.

(_SupportsComplexOps is the raw, non-caching version that defines the actual methods.)

>>> from typing import Any, Tuple, TypeVar
>>> from numerary.types import SupportsComplexOps
>>> MyComplexOpsT = TypeVar("MyComplexOpsT", bound=SupportsComplexOps)

>>> def complex_ops_my_thing(arg: MyComplexOpsT) -> MyComplexOpsT:
...   assert isinstance(arg, SupportsComplexOps)
...   return arg * -2 + 5

>>> complex_ops_my_thing(3)
-1

>>> from decimal import Decimal
>>> complex_ops_my_thing(Decimal("2.5"))
Decimal('0.0')

>>> import sympy
>>> complex_ops_my_thing(sympy.Float(3.5))
-2.0
>>> type(_)
<class 'sympy.core.numbers.Float'>

>>> # error: Value of type variable "MyComplexOpsT" of "complex_ops_my_thing" cannot be "str"
>>> complex_ops_my_thing("not-a-number")  # type: ignore [type-var]
Traceback (most recent call last):
  ...
AssertionError

Source code in numerary/types.py

@runtime_checkable
class SupportsComplexOps(
    _SupportsComplexOps[_T_co],
    Protocol,
    Generic[_T_co],
    metaclass=CachingProtocolMeta,
):
    r"""
    A caching ABC defining the [``Complex`` operator
    methods](https://docs.python.org/3/library/numbers.html#numbers.Complex) with
    covariant return values.

    ([``_SupportsComplexOps``][numerary.types._SupportsComplexOps] is the raw,
    non-caching version that defines the actual methods.)

    ``` python
    >>> from typing import Any, Tuple, TypeVar
    >>> from numerary.types import SupportsComplexOps
    >>> MyComplexOpsT = TypeVar("MyComplexOpsT", bound=SupportsComplexOps)

    >>> def complex_ops_my_thing(arg: MyComplexOpsT) -> MyComplexOpsT:
    ...   assert isinstance(arg, SupportsComplexOps)
    ...   return arg * -2 + 5

    >>> complex_ops_my_thing(3)
    -1

    >>> from decimal import Decimal
    >>> complex_ops_my_thing(Decimal("2.5"))
    Decimal('0.0')

    >>> import sympy
    >>> complex_ops_my_thing(sympy.Float(3.5))
    -2.0
    >>> type(_)
    <class 'sympy.core.numbers.Float'>

    >>> # error: Value of type variable "MyComplexOpsT" of "complex_ops_my_thing" cannot be "str"
    >>> complex_ops_my_thing("not-a-number")  # type: ignore [type-var]
    Traceback (most recent call last):
      ...
    AssertionError

    ```
    """

SupportsComplexPow

Bases: _SupportsComplexPow, Protocol

A caching ABC defining the Complex (i.e., non-modulo) versions of the __pow__ and __rpow__.

(_SupportsComplexPow is the raw, non-caching version that defines the actual methods.)

>>> from typing import Any, Tuple, TypeVar
>>> from numerary.types import SupportsComplexPow
>>> MyComplexPowT = TypeVar("MyComplexPowT", bound=SupportsComplexPow)

>>> def complex_pow_my_thing(arg: MyComplexPowT) -> MyComplexPowT:
...   assert isinstance(arg, SupportsComplexPow)
...   return arg ** -2

>>> complex_pow_my_thing(3)
0.1111111111111111

>>> from decimal import Decimal
>>> complex_pow_my_thing(Decimal("2.5"))
Decimal('0.16')

>>> import sympy
>>> complex_pow_my_thing(sympy.Float(3.5))
0.0816326530612245
>>> type(_)
<class 'sympy.core.numbers.Float'>

>>> # error: Value of type variable "MyComplexPowT" of "complex_pow_my_thing" cannot be "str"
>>> complex_pow_my_thing("not-a-number")  # type: ignore [type-var]
Traceback (most recent call last):
  ...
AssertionError

Source code in numerary/types.py

@runtime_checkable
class SupportsComplexPow(
    _SupportsComplexPow,
    Protocol,
    metaclass=CachingProtocolMeta,
):
    r"""
    A caching ABC defining the ``#!python Complex`` (i.e., non-modulo) versions of the
    [``__pow__``](https://docs.python.org/3/reference/datamodel.html#object.__pow__) and
    [``__rpow__``](https://docs.python.org/3/reference/datamodel.html#object.__rpow__).

    ([``_SupportsComplexPow``][numerary.types._SupportsComplexPow] is the raw,
    non-caching version that defines the actual methods.)

    ``` python
    >>> from typing import Any, Tuple, TypeVar
    >>> from numerary.types import SupportsComplexPow
    >>> MyComplexPowT = TypeVar("MyComplexPowT", bound=SupportsComplexPow)

    >>> def complex_pow_my_thing(arg: MyComplexPowT) -> MyComplexPowT:
    ...   assert isinstance(arg, SupportsComplexPow)
    ...   return arg ** -2

    >>> complex_pow_my_thing(3)
    0.1111111111111111

    >>> from decimal import Decimal
    >>> complex_pow_my_thing(Decimal("2.5"))
    Decimal('0.16')

    >>> import sympy
    >>> complex_pow_my_thing(sympy.Float(3.5))
    0.0816326530612245
    >>> type(_)
    <class 'sympy.core.numbers.Float'>

    >>> # error: Value of type variable "MyComplexPowT" of "complex_pow_my_thing" cannot be "str"
    >>> complex_pow_my_thing("not-a-number")  # type: ignore [type-var]
    Traceback (most recent call last):
      ...
    AssertionError

    ```
    """

SupportsRealOps

Bases: _SupportsRealOps[_T_co], Protocol, Generic[_T_co]

A caching ABC defining the Real operator methods with covariant return values.

(_SupportsRealOps is the raw, non-caching version that defines the actual methods.)

>>> from typing import Any, Tuple, TypeVar
>>> from numerary.types import SupportsRealOps
>>> MyRealOpsT = TypeVar("MyRealOpsT", bound=SupportsRealOps)

>>> def real_ops_my_thing(arg: MyRealOpsT) -> Any:
...   assert isinstance(arg, SupportsRealOps)
...   return arg // -2

>>> real_ops_my_thing(3)
-2

>>> from decimal import Decimal
>>> real_ops_my_thing(Decimal("2.5"))
Decimal('-1')

>>> import sympy
>>> real_ops_my_thing(sympy.Float(3.5))
-2
>>> type(_)
<class 'sympy.core.numbers.Integer'>

>>> # error: Value of type variable "MyRealOpsT" of "real_ops_my_thing" cannot be "str"
>>> real_ops_my_thing("not-a-number")  # type: ignore [type-var]
Traceback (most recent call last):
  ...
AssertionError

Source code in numerary/types.py

@runtime_checkable
class SupportsRealOps(
    _SupportsRealOps[_T_co],
    Protocol,
    Generic[_T_co],
    metaclass=CachingProtocolMeta,
):
    r"""
    A caching ABC defining the [``Real`` operator
    methods](https://docs.python.org/3/library/numbers.html#numbers.Real) with covariant
    return values.

    ([``_SupportsRealOps``][numerary.types._SupportsRealOps] is the raw, non-caching
    version that defines the actual methods.)

    ``` python
    >>> from typing import Any, Tuple, TypeVar
    >>> from numerary.types import SupportsRealOps
    >>> MyRealOpsT = TypeVar("MyRealOpsT", bound=SupportsRealOps)

    >>> def real_ops_my_thing(arg: MyRealOpsT) -> Any:
    ...   assert isinstance(arg, SupportsRealOps)
    ...   return arg // -2

    >>> real_ops_my_thing(3)
    -2

    >>> from decimal import Decimal
    >>> real_ops_my_thing(Decimal("2.5"))
    Decimal('-1')

    >>> import sympy
    >>> real_ops_my_thing(sympy.Float(3.5))
    -2
    >>> type(_)
    <class 'sympy.core.numbers.Integer'>

    >>> # error: Value of type variable "MyRealOpsT" of "real_ops_my_thing" cannot be "str"
    >>> real_ops_my_thing("not-a-number")  # type: ignore [type-var]
    Traceback (most recent call last):
      ...
    AssertionError

    ```
    """

SupportsIntegralOps

Bases: _SupportsIntegralOps[_T_co], Protocol, Generic[_T_co]

A caching ABC defining the Integral operator methods with covariant return values.

(_SupportsIntegralOps is the raw, non-caching version that defines the actual methods.)

>>> from typing import Any, Tuple, TypeVar
>>> from numerary.types import SupportsIntegralOps
>>> MyIntegralOpsT = TypeVar("MyIntegralOpsT", bound=SupportsIntegralOps)

>>> def integral_ops_my_thing(arg: MyIntegralOpsT) -> MyIntegralOpsT:
...   assert isinstance(arg, SupportsIntegralOps)
...   return arg << 1

>>> integral_ops_my_thing(3)
6

>>> import sympy
>>> integral_ops_my_thing(sympy.Integer(3))
6
>>> type(_)
<class 'sympy.core.numbers.Integer'>

>>> # error: Value of type variable "MyIntegralOpsT" of "integral_ops_my_thing" cannot be "str"
>>> integral_ops_my_thing("not-a-number")  # type: ignore [type-var]
Traceback (most recent call last):
  ...
AssertionError

Source code in numerary/types.py

@runtime_checkable
class SupportsIntegralOps(
    _SupportsIntegralOps[_T_co],
    Protocol,
    Generic[_T_co],
    metaclass=CachingProtocolMeta,
):
    r"""
    A caching ABC defining the [``Integral`` operator
    methods](https://docs.python.org/3/library/numbers.html#numbers.Integral) with
    covariant return values.

    ([``_SupportsIntegralOps``][numerary.types._SupportsIntegralOps] is the raw,
    non-caching version that defines the actual methods.)

    ``` python
    >>> from typing import Any, Tuple, TypeVar
    >>> from numerary.types import SupportsIntegralOps
    >>> MyIntegralOpsT = TypeVar("MyIntegralOpsT", bound=SupportsIntegralOps)

    >>> def integral_ops_my_thing(arg: MyIntegralOpsT) -> MyIntegralOpsT:
    ...   assert isinstance(arg, SupportsIntegralOps)
    ...   return arg << 1

    >>> integral_ops_my_thing(3)
    6

    >>> import sympy
    >>> integral_ops_my_thing(sympy.Integer(3))
    6
    >>> type(_)
    <class 'sympy.core.numbers.Integer'>

    >>> # error: Value of type variable "MyIntegralOpsT" of "integral_ops_my_thing" cannot be "str"
    >>> integral_ops_my_thing("not-a-number")  # type: ignore [type-var]
    Traceback (most recent call last):
      ...
    AssertionError

    ```
    """

SupportsIntegralPow

Bases: _SupportsIntegralPow, Protocol

A caching ABC defining the Integral (i.e., modulo) versions of the __pow__ and __rpow__ methods.

(_SupportsIntegralPow is the raw, non-caching version that defines the actual methods.)

>>> from typing import Any, Tuple, TypeVar
>>> from numerary.types import SupportsIntegralPow
>>> MyIntegralPowT = TypeVar("MyIntegralPowT", bound=SupportsIntegralPow)

>>> def integral_pow_my_thing(arg: MyIntegralPowT) -> MyIntegralPowT:
...   assert isinstance(arg, SupportsIntegralPow)
...   return pow(arg, 2, 2)

>>> integral_pow_my_thing(3)
1

>>> import sympy
>>> integral_pow_my_thing(sympy.Integer(3))
1
>>> type(_)
<class 'sympy.core.numbers.One'>

>>> # error: Value of type variable "MyIntegralPowT" of "integral_pow_my_thing" cannot be "str"
>>> integral_pow_my_thing("not-a-number")  # type: ignore [type-var]
Traceback (most recent call last):
  ...
AssertionError

Source code in numerary/types.py

@runtime_checkable
class SupportsIntegralPow(
    _SupportsIntegralPow,
    Protocol,
    metaclass=CachingProtocolMeta,
):
    r"""
    A caching ABC defining the ``#!python Integral`` (i.e., modulo) versions of the
    [``__pow__``](https://docs.python.org/3/reference/datamodel.html#object.__pow__) and
    [``__rpow__``](https://docs.python.org/3/reference/datamodel.html#object.__rpow__)
    methods.

    ([``_SupportsIntegralPow``][numerary.types._SupportsIntegralPow] is the raw,
    non-caching version that defines the actual methods.)

    ``` python
    >>> from typing import Any, Tuple, TypeVar
    >>> from numerary.types import SupportsIntegralPow
    >>> MyIntegralPowT = TypeVar("MyIntegralPowT", bound=SupportsIntegralPow)

    >>> def integral_pow_my_thing(arg: MyIntegralPowT) -> MyIntegralPowT:
    ...   assert isinstance(arg, SupportsIntegralPow)
    ...   return pow(arg, 2, 2)

    >>> integral_pow_my_thing(3)
    1

    >>> import sympy
    >>> integral_pow_my_thing(sympy.Integer(3))
    1
    >>> type(_)
    <class 'sympy.core.numbers.One'>

    >>> # error: Value of type variable "MyIntegralPowT" of "integral_pow_my_thing" cannot be "str"
    >>> integral_pow_my_thing("not-a-number")  # type: ignore [type-var]
    Traceback (most recent call last):
      ...
    AssertionError

    ```
    """

real(operand: SupportsRealImagMixedU)

Helper function that extracts the real part from operand including resolving non-compliant implementations that implement such extraction via a as_real_imag method rather than as properties.

>>> import sympy
>>> from numerary.types import real
>>> real(sympy.Float(3.5))
3.5

See SupportsRealImag and SupportsRealImagAsMethod.

Source code in numerary/types.py

@beartype
def real(operand: SupportsRealImagMixedU):
    r"""
    Helper function that extracts the real part from *operand* including resolving
    non-compliant implementations that implement such extraction via a ``as_real_imag``
    method rather than as properties.

    ``` python
    >>> import sympy
    >>> from numerary.types import real
    >>> real(sympy.Float(3.5))
    3.5

    ```

    See
    [SupportsRealImag][numerary.types.SupportsRealImag]
    and
    [SupportsRealImagAsMethod][numerary.types.SupportsRealImagAsMethod].
    """
    if callable(getattr(operand, "as_real_imag", None)):
        real_part, _ = operand.as_real_imag()  # type: ignore [union-attr]

        return real_part
    elif hasattr(operand, "real"):
        return operand.real
    else:
        raise TypeError(f"{operand!r} has no real or as_real_imag")

imag(operand: SupportsRealImagMixedU)

Helper function that extracts the imaginary part from operand including resolving non-compliant implementations that implement such extraction via a as_real_imag method rather than as properties.

>>> import sympy
>>> from numerary.types import real
>>> imag(sympy.Float(3.5))
0

See SupportsRealImag and SupportsRealImagAsMethod.

Source code in numerary/types.py

@beartype
def imag(operand: SupportsRealImagMixedU):
    r"""
    Helper function that extracts the imaginary part from *operand* including resolving
    non-compliant implementations that implement such extraction via a ``as_real_imag``
    method rather than as properties.

    ``` python
    >>> import sympy
    >>> from numerary.types import real
    >>> imag(sympy.Float(3.5))
    0

    ```

    See
    [SupportsRealImag][numerary.types.SupportsRealImag]
    and
    [SupportsRealImagAsMethod][numerary.types.SupportsRealImagAsMethod].
    """
    if callable(getattr(operand, "as_real_imag", None)):
        _, imag_part = operand.as_real_imag()  # type: ignore [union-attr]

        return imag_part
    elif hasattr(operand, "imag"):
        return operand.imag
    else:
        raise TypeError(f"{operand!r} has no real or as_real_imag")

__pow__(arg: Union[SupportsComplexPow, SupportsIntegralPow], exponent: Any, modulus: Optional[Any] = None) -> Any

Helper function that wraps pow to work with SupportsComplexPow, SupportsIntegralPow.

>>> from numerary.types import SupportsComplexPow, SupportsIntegralPow, __pow__
>>> my_complex_pow: SupportsComplexPow = complex(2)
>>> __pow__(my_complex_pow, 1)
(2+0j)
>>> __pow__(my_complex_pow, 1, None)
(2+0j)
>>> __pow__(my_complex_pow, 1, 1)  # type: ignore [operator]  # properly caught by Mypy
Traceback (most recent call last):
  ...
ValueError: complex modulo

>>> my_complex_pow = 1.2
>>> __pow__(my_complex_pow, 1)
1.2
>>> __pow__(my_complex_pow, 1, None)
1.2
>>> __pow__(my_complex_pow, 1, 1)  # ugh; *not* caught by Mypy because it treats floats as equivalent to ints?
Traceback (most recent call last):
  ...
TypeError: pow() 3rd argument not allowed unless all arguments are integers
>>> from fractions import Fraction

>>> my_complex_pow = Fraction(1, 2)
>>> __pow__(my_complex_pow, 1)
Fraction(1, 2)
>>> __pow__(my_complex_pow, 1, None)
Fraction(1, 2)
>>> __pow__(my_complex_pow, 1, 1)  # type: ignore [operator]  # properly caught by Mypy
Traceback (most recent call last):
  ...
TypeError: __pow__() takes 2 positional arguments but 3 were given

>>> from decimal import Decimal
>>> my_integral_pow: SupportsIntegralPow = Decimal("2")
>>> __pow__(my_integral_pow, 1)
Decimal('2')
>>> __pow__(my_integral_pow, 1, None)
Decimal('2')
>>> __pow__(my_integral_pow, 1, 2)
Decimal('0')

>>> my_integral_pow = Decimal("1.2")  # ruh-roh
>>> __pow__(my_integral_pow, 1)
Decimal('1.2')
>>> __pow__(my_integral_pow, 1, None)
Decimal('1.2')
>>> __pow__(my_integral_pow, 1, 2)  # not catchable by Mypy, since it works *some* of the time
Traceback (most recent call last):
  ...
decimal.InvalidOperation: [<class 'decimal.InvalidOperation'>]

>>> my_integral_pow = 2
>>> __pow__(my_integral_pow, 1)
2
>>> __pow__(my_integral_pow, 1, None)
2
>>> __pow__(my_integral_pow, 1, 2)
0

Source code in numerary/types.py

@beartype
def __pow__(
    arg: Union[SupportsComplexPow, SupportsIntegralPow],
    exponent: Any,
    modulus: Optional[Any] = None,
) -> Any:
    r"""
    Helper function that wraps ``pow`` to work with
    [``SupportsComplexPow``][numerary.types.SupportsComplexPow],
    [``SupportsIntegralPow``][numerary.types.SupportsIntegralPow].

    ``` python
    >>> from numerary.types import SupportsComplexPow, SupportsIntegralPow, __pow__
    >>> my_complex_pow: SupportsComplexPow = complex(2)
    >>> __pow__(my_complex_pow, 1)
    (2+0j)
    >>> __pow__(my_complex_pow, 1, None)
    (2+0j)
    >>> __pow__(my_complex_pow, 1, 1)  # type: ignore [operator]  # properly caught by Mypy
    Traceback (most recent call last):
      ...
    ValueError: complex modulo

    >>> my_complex_pow = 1.2
    >>> __pow__(my_complex_pow, 1)
    1.2
    >>> __pow__(my_complex_pow, 1, None)
    1.2
    >>> __pow__(my_complex_pow, 1, 1)  # ugh; *not* caught by Mypy because it treats floats as equivalent to ints?
    Traceback (most recent call last):
      ...
    TypeError: pow() 3rd argument not allowed unless all arguments are integers
    >>> from fractions import Fraction

    >>> my_complex_pow = Fraction(1, 2)
    >>> __pow__(my_complex_pow, 1)
    Fraction(1, 2)
    >>> __pow__(my_complex_pow, 1, None)
    Fraction(1, 2)
    >>> __pow__(my_complex_pow, 1, 1)  # type: ignore [operator]  # properly caught by Mypy
    Traceback (most recent call last):
      ...
    TypeError: __pow__() takes 2 positional arguments but 3 were given

    >>> from decimal import Decimal
    >>> my_integral_pow: SupportsIntegralPow = Decimal("2")
    >>> __pow__(my_integral_pow, 1)
    Decimal('2')
    >>> __pow__(my_integral_pow, 1, None)
    Decimal('2')
    >>> __pow__(my_integral_pow, 1, 2)
    Decimal('0')

    >>> my_integral_pow = Decimal("1.2")  # ruh-roh
    >>> __pow__(my_integral_pow, 1)
    Decimal('1.2')
    >>> __pow__(my_integral_pow, 1, None)
    Decimal('1.2')
    >>> __pow__(my_integral_pow, 1, 2)  # not catchable by Mypy, since it works *some* of the time
    Traceback (most recent call last):
      ...
    decimal.InvalidOperation: [<class 'decimal.InvalidOperation'>]

    >>> my_integral_pow = 2
    >>> __pow__(my_integral_pow, 1)
    2
    >>> __pow__(my_integral_pow, 1, None)
    2
    >>> __pow__(my_integral_pow, 1, 2)
    0

    ```
    """
    return pow(arg, exponent, modulus)

__trunc__(operand: Union[SupportsFloat, SupportsTrunc])

Helper function that wraps math.trunc.

>>> from numerary.types import SupportsFloat, SupportsTrunc, __trunc__
>>> my_trunc: SupportsTrunc
>>> my_trunc = 1
>>> __trunc__(my_trunc)
1
>>> from fractions import Fraction
>>> my_trunc = Fraction(1, 2)
>>> __trunc__(my_trunc)
0
>>> my_trunc_float: SupportsFloat = 1.2
>>> __trunc__(my_trunc_float)
1

Source code in numerary/types.py

@beartype
def __trunc__(operand: Union[SupportsFloat, SupportsTrunc]):
    r"""
    Helper function that wraps ``math.trunc``.

    ``` python
    >>> from numerary.types import SupportsFloat, SupportsTrunc, __trunc__
    >>> my_trunc: SupportsTrunc
    >>> my_trunc = 1
    >>> __trunc__(my_trunc)
    1
    >>> from fractions import Fraction
    >>> my_trunc = Fraction(1, 2)
    >>> __trunc__(my_trunc)
    0
    >>> my_trunc_float: SupportsFloat = 1.2
    >>> __trunc__(my_trunc_float)
    1

    ```
    """
    return math.trunc(operand)  # type: ignore [arg-type]

__floor__(operand: Union[SupportsFloat, SupportsFloorCeil])

Helper function that wraps math.floor.

>>> from numerary.types import SupportsFloat, SupportsFloorCeil, __floor__
>>> my_floor: SupportsFloorCeil
>>> my_floor = 1
>>> __floor__(my_floor)
1
>>> from fractions import Fraction
>>> my_floor = Fraction(1, 2)
>>> __floor__(my_floor)
0
>>> my_floor_float: SupportsFloat = 1.2
>>> __floor__(my_floor_float)
1

Source code in numerary/types.py

@beartype
def __floor__(operand: Union[SupportsFloat, SupportsFloorCeil]):
    r"""
    Helper function that wraps ``math.floor``.

    ``` python
    >>> from numerary.types import SupportsFloat, SupportsFloorCeil, __floor__
    >>> my_floor: SupportsFloorCeil
    >>> my_floor = 1
    >>> __floor__(my_floor)
    1
    >>> from fractions import Fraction
    >>> my_floor = Fraction(1, 2)
    >>> __floor__(my_floor)
    0
    >>> my_floor_float: SupportsFloat = 1.2
    >>> __floor__(my_floor_float)
    1

    ```
    """
    return math.floor(operand)

__ceil__(operand: Union[SupportsFloat, SupportsFloorCeil])

Helper function that wraps math.ceil.

>>> from numerary.types import SupportsFloat, SupportsFloorCeil, __ceil__
>>> my_ceil: SupportsFloorCeil
>>> my_ceil = 1
>>> __ceil__(my_ceil)
1
>>> from fractions import Fraction
>>> my_ceil = Fraction(1, 2)
>>> __ceil__(my_ceil)
1
>>> my_ceil_float: SupportsFloat = 1.2
>>> __ceil__(my_ceil_float)
2

Source code in numerary/types.py

@beartype
def __ceil__(operand: Union[SupportsFloat, SupportsFloorCeil]):
    r"""
    Helper function that wraps ``math.ceil``.

    ``` python
    >>> from numerary.types import SupportsFloat, SupportsFloorCeil, __ceil__
    >>> my_ceil: SupportsFloorCeil
    >>> my_ceil = 1
    >>> __ceil__(my_ceil)
    1
    >>> from fractions import Fraction
    >>> my_ceil = Fraction(1, 2)
    >>> __ceil__(my_ceil)
    1
    >>> my_ceil_float: SupportsFloat = 1.2
    >>> __ceil__(my_ceil_float)
    2

    ```
    """
    return math.ceil(operand)

numerator(operand: SupportsNumeratorDenominatorMixedU)

Helper function that extracts the numerator from operand including resolving non-compliant rational implementations that implement numerator as a method rather than a property.

>>> from fractions import Fraction
>>> from numerary.types import numerator
>>> numerator(Fraction(22, 7))
22

See SupportsNumeratorDenominator and SupportsNumeratorDenominatorMethods.

Source code in numerary/types.py

@beartype
def numerator(operand: SupportsNumeratorDenominatorMixedU):
    r"""
    Helper function that extracts the numerator from *operand* including resolving
    non-compliant rational implementations that implement ``numerator`` as a method
    rather than a property.

    ``` python
    >>> from fractions import Fraction
    >>> from numerary.types import numerator
    >>> numerator(Fraction(22, 7))
    22

    ```

    See
    [SupportsNumeratorDenominator][numerary.types.SupportsNumeratorDenominator]
    and
    [SupportsNumeratorDenominatorMethods][numerary.types.SupportsNumeratorDenominatorMethods].
    """
    if hasattr(operand, "numerator"):
        if callable(operand.numerator):
            return operand.numerator()
        else:
            return operand.numerator
    else:
        raise TypeError(f"{operand!r} has no numerator")

denominator(operand: SupportsNumeratorDenominatorMixedU)

Helper function that extracts the denominator from operand including resolving non-compliant rational implementations that implement denominator as a method rather than a property.

>>> from fractions import Fraction
>>> from numerary.types import denominator
>>> denominator(Fraction(22, 7))
7

See SupportsNumeratorDenominator and SupportsNumeratorDenominatorMethods.

Source code in numerary/types.py

@beartype
def denominator(operand: SupportsNumeratorDenominatorMixedU):
    r"""
    Helper function that extracts the denominator from *operand* including resolving
    non-compliant rational implementations that implement ``denominator`` as a method
    rather than a property.

    ``` python
    >>> from fractions import Fraction
    >>> from numerary.types import denominator
    >>> denominator(Fraction(22, 7))
    7

    ```

    See
    [SupportsNumeratorDenominator][numerary.types.SupportsNumeratorDenominator]
    and
    [SupportsNumeratorDenominatorMethods][numerary.types.SupportsNumeratorDenominatorMethods].
    """
    if hasattr(operand, "denominator"):
        if callable(operand.denominator):
            return operand.denominator()
        else:
            return operand.denominator
    else:
        raise TypeError(f"{operand!r} has no denominator")

RationalLikeMixedT = (RationalLike, RationalLikeMethods) module-attribute

RationalLikeMixedU = Union[RationalLike, RationalLikeMethods] module-attribute

SupportsRealImagMixedT = (SupportsRealImag, SupportsRealImagAsMethod) module-attribute

SupportsRealImagMixedU = Union[SupportsRealImag, SupportsRealImagAsMethod] module-attribute

SupportsNumeratorDenominatorMixedT = (SupportsNumeratorDenominator, SupportsNumeratorDenominatorMethods) module-attribute

SupportsNumeratorDenominatorMixedU = Union[SupportsNumeratorDenominator, SupportsNumeratorDenominatorMethods] module-attribute

_SupportsConjugate

Bases: _Protocol

The non-caching version of SupportsConjugate.

Source code in numerary/types.py

@runtime_checkable
class _SupportsConjugate(_Protocol):
    r"""
    The non-caching version of
    [``SupportsConjugate``][numerary.types.SupportsConjugate].
    """

    @abstractmethod
    def conjugate(self) -> Any:
        pass

conjugate() -> Any abstractmethod

Source code in numerary/types.py

@abstractmethod
def conjugate(self) -> Any:
    pass

_SupportsRealImag

Bases: _Protocol

The non-caching version of SupportsRealImag.

Source code in numerary/types.py

@runtime_checkable
class _SupportsRealImag(_Protocol):
    r"""
    The non-caching version of [``SupportsRealImag``][numerary.types.SupportsRealImag].
    """

    @abstractproperty
    def real(self) -> Any:
        pass

    @abstractproperty
    def imag(self) -> Any:
        pass

imag() -> Any

Source code in numerary/types.py

@abstractproperty
def imag(self) -> Any:
    pass

real() -> Any

Source code in numerary/types.py

@abstractproperty
def real(self) -> Any:
    pass

_SupportsRealImagAsMethod

Bases: _Protocol

The non-caching version of SupportsRealImagAsMethod.

Source code in numerary/types.py

@runtime_checkable
class _SupportsRealImagAsMethod(_Protocol):
    r"""
    The non-caching version of
    [``SupportsRealImagAsMethod``][numerary.types.SupportsRealImagAsMethod].
    """

    @abstractmethod
    def as_real_imag(self) -> Tuple[Any, Any]:
        pass

as_real_imag() -> Tuple[Any, Any] abstractmethod

Source code in numerary/types.py

@abstractmethod
def as_real_imag(self) -> Tuple[Any, Any]:
    pass

_SupportsTrunc

Bases: _Protocol

The non-caching version of SupportsTrunc.

Source code in numerary/types.py

@runtime_checkable
class _SupportsTrunc(_Protocol):
    r"""
    The non-caching version of [``SupportsTrunc``][numerary.types.SupportsTrunc].
    """

    @abstractmethod
    def __trunc__(self) -> int:
        pass

__trunc__() -> int abstractmethod

Source code in numerary/types.py

@abstractmethod
def __trunc__(self) -> int:
    pass

_SupportsFloorCeil

Bases: _Protocol

The non-caching version of SupportsFloorCeil.

Source code in numerary/types.py

@runtime_checkable
class _SupportsFloorCeil(_Protocol):
    r"""
    The non-caching version of
    [``SupportsFloorCeil``][numerary.types.SupportsFloorCeil].
    """

    @abstractmethod
    def __floor__(self) -> int:
        pass

    @abstractmethod
    def __ceil__(self) -> int:
        pass

__ceil__() -> int abstractmethod

Source code in numerary/types.py

@abstractmethod
def __ceil__(self) -> int:
    pass

__floor__() -> int abstractmethod

Source code in numerary/types.py

@abstractmethod
def __floor__(self) -> int:
    pass

_SupportsDivmod

Bases: _Protocol, Generic[_T_co]

The non-caching version of SupportsDivmod.

Source code in numerary/types.py

@runtime_checkable
class _SupportsDivmod(
    _Protocol,
    Generic[_T_co],
):
    r"""
    The non-caching version of [``SupportsDivmod``][numerary.types.SupportsDivmod].
    """

    @abstractmethod
    def __divmod__(self, other: Any) -> Tuple[_T_co, _T_co]:
        pass

    @abstractmethod
    def __rdivmod__(self, other: Any) -> Tuple[_T_co, _T_co]:
        pass

__divmod__(other: Any) -> Tuple[_T_co, _T_co] abstractmethod

Source code in numerary/types.py

@abstractmethod
def __divmod__(self, other: Any) -> Tuple[_T_co, _T_co]:
    pass

__rdivmod__(other: Any) -> Tuple[_T_co, _T_co] abstractmethod

Source code in numerary/types.py

@abstractmethod
def __rdivmod__(self, other: Any) -> Tuple[_T_co, _T_co]:
    pass

_SupportsNumeratorDenominator

Bases: _Protocol

The non-caching version of SupportsNumeratorDenominator.

Source code in numerary/types.py

@runtime_checkable
class _SupportsNumeratorDenominator(_Protocol):
    r"""
    The non-caching version of
    [``SupportsNumeratorDenominator``][numerary.types.SupportsNumeratorDenominator].
    """

    @abstractproperty
    def numerator(self) -> int:
        pass

    @abstractproperty
    def denominator(self) -> int:
        pass

denominator() -> int

Source code in numerary/types.py

@abstractproperty
def denominator(self) -> int:
    pass

numerator() -> int

Source code in numerary/types.py

@abstractproperty
def numerator(self) -> int:
    pass

_SupportsNumeratorDenominatorMethods

Bases: _Protocol

The non-caching version of SupportsNumeratorDenominatorMethods.

Source code in numerary/types.py

@runtime_checkable
class _SupportsNumeratorDenominatorMethods(_Protocol):
    r"""
    The non-caching version of
    [``SupportsNumeratorDenominatorMethods``][numerary.types.SupportsNumeratorDenominatorMethods].
    """

    @abstractmethod
    def numerator(self) -> SupportsInt:
        pass

    @abstractmethod
    def denominator(self) -> SupportsInt:
        pass

denominator() -> SupportsInt abstractmethod

Source code in numerary/types.py

@abstractmethod
def denominator(self) -> SupportsInt:
    pass

numerator() -> SupportsInt abstractmethod

Source code in numerary/types.py

@abstractmethod
def numerator(self) -> SupportsInt:
    pass

_SupportsComplexOps

Bases: _Protocol, Generic[_T_co]

The non-caching version of SupportsComplexOps.

Source code in numerary/types.py

@runtime_checkable
class _SupportsComplexOps(
    _Protocol,
    Generic[_T_co],
):
    r"""
    The non-caching version of
    [``SupportsComplexOps``][numerary.types.SupportsComplexOps].
    """

    @abstractmethod
    def __add__(self, other: Any) -> _T_co:
        pass

    @abstractmethod
    def __radd__(self, other: Any) -> _T_co:
        pass

    @abstractmethod
    def __sub__(self, other: Any) -> _T_co:
        pass

    @abstractmethod
    def __rsub__(self, other: Any) -> _T_co:
        pass

    @abstractmethod
    def __mul__(self, other: Any) -> _T_co:
        pass

    @abstractmethod
    def __rmul__(self, other: Any) -> _T_co:
        pass

    @abstractmethod
    def __truediv__(self, other: Any) -> _T_co:
        pass

    @abstractmethod
    def __rtruediv__(self, other: Any) -> _T_co:
        pass

    @abstractmethod
    def __neg__(self) -> _T_co:
        pass

    @abstractmethod
    def __pos__(self) -> _T_co:
        pass

__add__(other: Any) -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __add__(self, other: Any) -> _T_co:
    pass

__mul__(other: Any) -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __mul__(self, other: Any) -> _T_co:
    pass

__neg__() -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __neg__(self) -> _T_co:
    pass

__pos__() -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __pos__(self) -> _T_co:
    pass

__radd__(other: Any) -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __radd__(self, other: Any) -> _T_co:
    pass

__rmul__(other: Any) -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __rmul__(self, other: Any) -> _T_co:
    pass

__rsub__(other: Any) -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __rsub__(self, other: Any) -> _T_co:
    pass

__rtruediv__(other: Any) -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __rtruediv__(self, other: Any) -> _T_co:
    pass

__sub__(other: Any) -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __sub__(self, other: Any) -> _T_co:
    pass

__truediv__(other: Any) -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __truediv__(self, other: Any) -> _T_co:
    pass

_SupportsComplexPow

Bases: _Protocol

The non-caching version of SupportsComplexPow.

Source code in numerary/types.py

@runtime_checkable
class _SupportsComplexPow(_Protocol):
    r"""
    The non-caching version of
    [``SupportsComplexPow``][numerary.types.SupportsComplexPow].
    """

    @abstractmethod
    def __pow__(self, exponent: Any) -> Any:
        pass

    @abstractmethod
    def __rpow__(self, exponent: Any) -> Any:
        pass

__pow__(exponent: Any) -> Any abstractmethod

Source code in numerary/types.py

@abstractmethod
def __pow__(self, exponent: Any) -> Any:
    pass

__rpow__(exponent: Any) -> Any abstractmethod

Source code in numerary/types.py

@abstractmethod
def __rpow__(self, exponent: Any) -> Any:
    pass

_SupportsRealOps

Bases: _Protocol, Generic[_T_co]

The non-caching version of SupportsRealOps.

Source code in numerary/types.py

@runtime_checkable
class _SupportsRealOps(
    _Protocol,
    Generic[_T_co],
):
    r"""
    The non-caching version of [``SupportsRealOps``][numerary.types.SupportsRealOps].
    """

    @abstractmethod
    def __lt__(self, other: Any) -> bool:
        pass

    @abstractmethod
    def __le__(self, other: Any) -> bool:
        pass

    @abstractmethod
    def __ge__(self, other: Any) -> bool:
        pass

    @abstractmethod
    def __gt__(self, other: Any) -> bool:
        pass

    @abstractmethod
    def __floordiv__(self, other: Any) -> Any:  # TODO(posita): should be int
        pass

    @abstractmethod
    def __rfloordiv__(self, other: Any) -> Any:  # TODO(posita): should be int
        pass

    @abstractmethod
    def __mod__(self, other: Any) -> _T_co:
        pass

    @abstractmethod
    def __rmod__(self, other: Any) -> _T_co:
        pass

__floordiv__(other: Any) -> Any abstractmethod

Source code in numerary/types.py

@abstractmethod
def __floordiv__(self, other: Any) -> Any:  # TODO(posita): should be int
    pass

__ge__(other: Any) -> bool abstractmethod

Source code in numerary/types.py

@abstractmethod
def __ge__(self, other: Any) -> bool:
    pass

__gt__(other: Any) -> bool abstractmethod

Source code in numerary/types.py

@abstractmethod
def __gt__(self, other: Any) -> bool:
    pass

__le__(other: Any) -> bool abstractmethod

Source code in numerary/types.py

@abstractmethod
def __le__(self, other: Any) -> bool:
    pass

__lt__(other: Any) -> bool abstractmethod

Source code in numerary/types.py

@abstractmethod
def __lt__(self, other: Any) -> bool:
    pass

__mod__(other: Any) -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __mod__(self, other: Any) -> _T_co:
    pass

__rfloordiv__(other: Any) -> Any abstractmethod

Source code in numerary/types.py

@abstractmethod
def __rfloordiv__(self, other: Any) -> Any:  # TODO(posita): should be int
    pass

__rmod__(other: Any) -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __rmod__(self, other: Any) -> _T_co:
    pass

_SupportsIntegralOps

Bases: _Protocol, Generic[_T_co]

The non-caching version of SupportsIntegralOps.

Source code in numerary/types.py

@runtime_checkable
class _SupportsIntegralOps(
    _Protocol,
    Generic[_T_co],
):
    r"""
    The non-caching version of
    [``SupportsIntegralOps``][numerary.types.SupportsIntegralOps].
    """

    @abstractmethod
    def __lshift__(self, other: Any) -> _T_co:
        pass

    @abstractmethod
    def __rlshift__(self, other: Any) -> _T_co:
        pass

    @abstractmethod
    def __rshift__(self, other: Any) -> _T_co:
        pass

    @abstractmethod
    def __rrshift__(self, other: Any) -> _T_co:
        pass

    @abstractmethod
    def __and__(self, other: Any) -> _T_co:
        pass

    @abstractmethod
    def __rand__(self, other: Any) -> _T_co:
        pass

    @abstractmethod
    def __xor__(self, other: Any) -> _T_co:
        pass

    @abstractmethod
    def __rxor__(self, other: Any) -> _T_co:
        pass

    @abstractmethod
    def __or__(self, other: Any) -> _T_co:
        pass

    @abstractmethod
    def __ror__(self, other: Any) -> _T_co:
        pass

    @abstractmethod
    def __invert__(self) -> _T_co:
        pass

__and__(other: Any) -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __and__(self, other: Any) -> _T_co:
    pass

__invert__() -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __invert__(self) -> _T_co:
    pass

__lshift__(other: Any) -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __lshift__(self, other: Any) -> _T_co:
    pass

__or__(other: Any) -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __or__(self, other: Any) -> _T_co:
    pass

__rand__(other: Any) -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __rand__(self, other: Any) -> _T_co:
    pass

__rlshift__(other: Any) -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __rlshift__(self, other: Any) -> _T_co:
    pass

__ror__(other: Any) -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __ror__(self, other: Any) -> _T_co:
    pass

__rrshift__(other: Any) -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __rrshift__(self, other: Any) -> _T_co:
    pass

__rshift__(other: Any) -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __rshift__(self, other: Any) -> _T_co:
    pass

__rxor__(other: Any) -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __rxor__(self, other: Any) -> _T_co:
    pass

__xor__(other: Any) -> _T_co abstractmethod

Source code in numerary/types.py

@abstractmethod
def __xor__(self, other: Any) -> _T_co:
    pass

_SupportsIntegralPow

Bases: _Protocol

The non-caching version of SupportsIntegralPow.

Source code in numerary/types.py

@runtime_checkable
class _SupportsIntegralPow(_Protocol):
    r"""
    The non-caching version of
    [``SupportsIntegralPow``][numerary.types.SupportsIntegralPow].
    """

    @abstractmethod
    def __pow__(self, exponent: Any, modulus: Optional[Any] = None) -> Any:
        pass

    @abstractmethod
    def __rpow__(self, exponent: Any, modulus: Optional[Any] = None) -> Any:
        pass

__pow__(exponent: Any, modulus: Optional[Any] = None) -> Any abstractmethod

Source code in numerary/types.py

@abstractmethod
def __pow__(self, exponent: Any, modulus: Optional[Any] = None) -> Any:
    pass

__rpow__(exponent: Any, modulus: Optional[Any] = None) -> Any abstractmethod

Source code in numerary/types.py

@abstractmethod
def __rpow__(self, exponent: Any, modulus: Optional[Any] = None) -> Any:
    pass