Add type annotations for rings and parents

Author: tobiasdiez

src/sage/categories/map.pyi

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+from typing import Any, Callable, Generic, Iterator, Mapping, Self, Sequence, TypeVar
+
+from sage.categories.category import Category
+from sage.structure.element import Element
+from sage.structure.parent import Parent
+
+DomainElementT_contra = TypeVar("DomainElementT_contra", contravariant=True)
+CodomainElementT_co = TypeVar("CodomainElementT_co", covariant=True)
+SectionDomainT = TypeVar("SectionDomainT")
+SectionCodomainT = TypeVar("SectionCodomainT")
+CompositeDomainT = TypeVar("CompositeDomainT")
+CompositeCodomainT = TypeVar("CompositeCodomainT")
+
+
+class Map(Element, Generic[DomainElementT_contra, CodomainElementT_co]):
+    _coerce_cost: int
+    _is_coercion: bool
+    _repr_type_str: str | None
+    _category_for: Category | None
+    domain: Callable[[], Parent[Any] | None]
+    codomain: Callable[[], Parent[Any]]
+    _codomain: Parent[Any]
+
+    def __init__(self, parent: Any, codomain: Parent[Any] | None = ...) -> None: ...
+    def __copy__(self) -> Self: ...
+    def parent(self) -> Any: ...
+    def _make_weak_references(self) -> None: ...
+    def _make_strong_references(self) -> None: ...
+    def _update_slots(self, slots: Mapping[str, Any]) -> None: ...
+    def _update_slots_test(self, _slots: Mapping[str, Any]) -> None: ...
+    def _extra_slots(self) -> dict[str, Any]: ...
+    def _extra_slots_test(self) -> dict[str, Any]: ...
+    def __reduce__(self) -> tuple[Any, tuple[Any, ...]]: ...
+    def _repr_type(self) -> str: ...
+    def _repr_defn(self) -> str: ...
+    def _repr_(self) -> str: ...
+    def _default_repr_(self) -> str: ...
+    def domains(self) -> Iterator[Parent[Any] | None]: ...
+    def category_for(self) -> Category: ...
+    def __call__(self, x: DomainElementT_contra, *args: Any, **kwds: Any) -> CodomainElementT_co: ...
+    def _call_(self, x: DomainElementT_contra) -> CodomainElementT_co: ...
+    def _call_with_args(
+        self,
+        x: DomainElementT_contra,
+        args: Sequence[Any] = ...,
+        kwds: Mapping[str, Any] | None = ...,
+    ) -> CodomainElementT_co: ...
+    def __mul__(self, right: Map[Any, Any]) -> Map[Any, Any]: ...
+    def _composition(self, right: Map[Any, Any]) -> Map[Any, Any]: ...
+    def _composition_(self, right: Map[Any, Any], homset: Any) -> Map[Any, Any]: ...
+    def pre_compose(self, right: Map[Any, Any]) -> Map[Any, Any]: ...
+    def post_compose(self, left: Map[Any, Any]) -> Map[Any, Any]: ...
+    def extend_domain(self, new_domain: Any) -> Map[Any, Any]: ...
+    def extend_codomain(self, new_codomain: Any) -> Map[Any, Any]: ...
+    def is_surjective(self) -> bool: ...
+    def _pow_int(self, n: int) -> Map[Any, Any]: ...
+    def section(self) -> Map[Any, Any] | None: ...
+    def __hash__(self) -> int: ...
+
+
+class Section(Map[SectionCodomainT, SectionDomainT], Generic[SectionDomainT, SectionCodomainT]):
+    _inverse: Map[SectionDomainT, SectionCodomainT]
+
+    def __init__(self, map: Map[SectionDomainT, SectionCodomainT]) -> None: ...
+    def _extra_slots(self) -> dict[str, Any]: ...
+    def _update_slots(self, slots: Mapping[str, Any]) -> None: ...
+    def _repr_type(self) -> str: ...
+    def inverse(self) -> Map[SectionDomainT, SectionCodomainT]: ...
+
+
+class FormalCompositeMap(
+    Map[CompositeDomainT, CompositeCodomainT],
+    Generic[CompositeDomainT, CompositeCodomainT],
+):
+    __list: Sequence[Map[Any, Any]]
+
+    def __init__(
+        self,
+        parent: Any,
+        first: Map[Any, Any] | Sequence[Map[Any, Any]],
+        second: Map[Any, Any] | None = ...,
+    ) -> None: ...
+    def __copy__(self) -> Self: ...
+    def _update_slots(self, slots: Mapping[str, Any]) -> None: ...
+    def _extra_slots(self) -> dict[str, Any]: ...
+    def __richcmp__(self, other: Any, op: int) -> bool: ...
+    def __hash__(self) -> int: ...
+    def __getitem__(self, i: int) -> Map[Any, Any]: ...
+    def _call_(self, x: CompositeDomainT) -> CompositeCodomainT: ...
+    def _call_with_args(
+        self,
+        x: CompositeDomainT,
+        args: Sequence[Any] = ...,
+        kwds: Mapping[str, Any] | None = ...,
+    ) -> CompositeCodomainT: ...
+    def _repr_type(self) -> str: ...
+    def _repr_defn(self) -> str: ...
+    def first(self) -> Map[Any, Any]: ...
+    def then(self) -> Map[Any, Any]: ...
+    def is_injective(self) -> bool: ...
+    def is_surjective(self) -> bool: ...
+    def domains(self) -> Iterator[Parent[Any] | None]: ...
+    def section(self) -> Map[Any, Any] | None: ...
+
+
+def unpickle_map(
+    _class: type[Map[Any, Any]],
+    parent: Any,
+    _dict: Mapping[str, Any],
+    _slots: Mapping[str, Any],
+) -> Map[Any, Any]: ...
+
+
+def is_Map(x: Any) -> bool: ...

src/sage/rings/complex_conversion.pyi

@@ -1,8 +1,8 @@
-from typing import Any
 
-from sage.structure.element import Element
 from sage.categories.map import Map
+from sage.rings.complex_double import ComplexDoubleElement
+from sage.rings.complex_mpfr import ComplexNumber
 
-class CCtoCDF(Map):
-    def _call_(self, x: Element) -> Element:
+class CCtoCDF(Map[ComplexNumber, ComplexDoubleElement]):
+    def _call_(self, x: ComplexNumber) -> ComplexDoubleElement:
         ...

src/sage/rings/complex_interval_field.py

@@ -34,9 +34,10 @@
 # (at your option) any later version.
 #                  https://www.gnu.org/licenses/
 # ****************************************************************************
-
+from __future__ import annotations
 
 import weakref
+from typing import Literal
 
 import sage.rings.abc
 from sage.misc.cachefunc import cached_method
@@ -48,10 +49,10 @@
 from sage.rings.ring import Field
 from sage.structure.parent import Parent
 
-cache = {}
+cache: dict[int, weakref.ReferenceType[ComplexIntervalField_class]] = {}
 
 
-def ComplexIntervalField(prec=53, names=None):
+def ComplexIntervalField(prec=53, names=None) -> ComplexIntervalField_class:
     """
     Return the complex interval field with real and imaginary parts having
     ``prec`` *bits* of precision.
@@ -182,7 +183,7 @@ class ComplexIntervalField_class(sage.rings.abc.ComplexIntervalField):
     """
     Element = complex_interval.ComplexIntervalFieldElement
 
-    def __init__(self, prec=53):
+    def __init__(self, prec=53) -> None:
         """
         Initialize ``self``.
 
@@ -243,7 +244,7 @@ def construction(self):
         from sage.categories.pushout import AlgebraicClosureFunctor
         return (AlgebraicClosureFunctor(), self.real_field())
 
-    def is_exact(self):
+    def is_exact(self) -> Literal[False]:
         """
         The complex interval field is not exact.
 
@@ -254,7 +255,7 @@ def is_exact(self):
         """
         return False
 
-    def prec(self):
+    def prec(self) -> int:
         """
         Return the precision of ``self`` (in bits).
 
@@ -267,7 +268,7 @@ def prec(self):
         """
         return self._prec
 
-    def to_prec(self, prec):
+    def to_prec(self, prec) -> ComplexIntervalField_class:
         """
         Return a complex interval field with the given precision.
 
@@ -282,7 +283,7 @@ def to_prec(self, prec):
         """
         return ComplexIntervalField(prec)
 
-    def _magma_init_(self, magma):
+    def _magma_init_(self, magma) -> str:
         r"""
         Return a string representation of ``self`` in the Magma language.
 
@@ -386,7 +387,7 @@ def __eq__(self, other):
             return False
         return self._prec == other._prec
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         """
         Return the hash.
 
@@ -400,7 +401,7 @@ def __hash__(self):
         """
         return hash((self.__class__, self._prec))
 
-    def __ne__(self, other):
+    def __ne__(self, other) -> bool:
         """
         Test whether ``self`` is not equal to ``other``.
 
@@ -650,7 +651,7 @@ def ngens(self):
         """
         return 1
 
-    def zeta(self, n=2):
+    def zeta(self, n: int = 2):
         r"""
         Return a primitive `n`-th root of unity.
 

src/sage/rings/morphism.pyi

@@ -1,15 +1,16 @@
-from sage.rings.integer import Integer
-from sage.structure.element import Element
-from sage.structure.parent import Parent
+from typing import Any
+
 from sage.categories.map import Map
 from sage.categories.morphism import Morphism
+from sage.rings.integer import Integer
+from sage.structure.parent import Parent
 
 class RingMap(Morphism):
     pass
 
 class RingMap_lift(RingMap):
-    S: Parent
-    to_S: Map
+    S: Parent[Any]
+    to_S: Map[Any, Any]
 
 class RingHomomorphism(RingMap):
     _lift: Morphism

src/sage/rings/ring.pyi

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+from typing import Any, Iterator, NoReturn
+
+from sage.categories.category import Category
+from sage.categories.commutative_rings import CommutativeRings
+from sage.categories.fields import Fields
+from sage.categories.rings import Rings
+from sage.structure.category_object import NameSpec
+from sage.structure.parent import Parent
+from sage.structure.parent_gens import ParentWithGens
+
+_Rings: Rings
+_CommutativeRings: CommutativeRings
+_Fields: Fields
+
+
+class Ring(ParentWithGens):
+    _default_category: Category
+
+    def __init__(
+        self,
+        base: Parent[Any] | object,
+        names: NameSpec = ...,
+        normalize: bool = ...,
+        category: Category | None = ...,
+    ) -> None: ...
+
+    def __iter__(self) -> Iterator[Any]: ...
+    def __len__(self) -> int: ...
+    def __xor__(self, n: object) -> NoReturn: ...
+    def base_extend(self, X: Parent[Any]) -> Parent[Any]: ...
+    def category(self) -> Category: ...
+    def __mul__(self, x: object) -> object: ...
+    def zero(self) -> Any: ...
+    def one(self) -> Any: ...
+    def order(self) -> int: ...
+
+
+class CommutativeRing(Ring):
+    _default_category: Category
+
+    def __init__(
+        self,
+        base_ring: Parent[Any] | object,
+        names: NameSpec = ...,
+        normalize: bool = ...,
+        category: Category | None = ...,
+    ) -> None: ...
+
+    def fraction_field(self) -> Ring: ...
+    def extension(
+        self,
+        poly: object,
+        name: str | None = ...,
+        names: NameSpec = ...,
+        **kwds: object,
+    ) -> Ring: ...
+
+
+class IntegralDomain(CommutativeRing):
+    _default_category: Category
+
+
+class NoetherianRing(CommutativeRing):
+    _default_category: Category
+
+
+class DedekindDomain(CommutativeRing):
+    _default_category: Category
+
+
+class PrincipalIdealDomain(CommutativeRing):
+    _default_category: Category
+
+
+def _is_Field(x: object) -> bool: ...
+
+
+class Field(CommutativeRing):
+    _default_category: Category
+
+
+class Algebra(Ring):
+    def __init__(self, base_ring: Parent[Any] | object, *args: object, **kwds: object) -> None: ...
+
+
+class CommutativeAlgebra(CommutativeRing):
+    def __init__(self, base_ring: Parent[Any] | object, *args: object, **kwds: object) -> None: ...
+
+
+def is_Ring(x: object) -> bool: ...