Trac #34804: Deprecate sage.interfaces is_...Element functions

Introducing a module `sage.interfaces.abc` with abstract base classes
for `isinstance` testing (see
https://doc.sagemath.org/html/en/developer/packaging_sage_library.html
#module-level-runtime-dependencies)

Part of #32414

URL: https://trac.sagemath.org/34804
Reported by: mkoeppe
Ticket author(s): Matthias Koeppe, Dima Pasechnik
Reviewer(s): Dima Pasechnik

Author: Release Manager

src/doc/en/reference/interfaces/index.rst

@@ -63,6 +63,7 @@ and testing to make sure nothing funny is going on).
    sage/interfaces/interface
    sage/interfaces/expect
    sage/interfaces/sagespawn
+   sage/interfaces/abc
    sage/interfaces/axiom
    sage/interfaces/ecm
    sage/interfaces/four_ti_2

src/sage/algebras/commutative_dga.py

@@ -100,6 +100,8 @@
 from sage.rings.quotient_ring_element import QuotientRingElement
 from sage.misc.cachefunc import cached_function
 
+import sage.interfaces.abc
+
 
 def sorting_keys(element):
     r"""
@@ -1262,8 +1264,7 @@ def _element_constructor_(self, x, coerce=True):
             R = self.cover_ring()
             x = R(x)
 
-        from sage.interfaces.singular import is_SingularElement
-        if is_SingularElement(x):
+        if isinstance(x, sage.interfaces.abc.SingularElement):
             # self._singular_().set_ring()
             x = self.element_class(self, x.sage_poly(self.cover_ring()))
             return x

src/sage/groups/perm_gps/permgroup.py

@@ -142,8 +142,7 @@
 from sage.groups.group import FiniteGroup
 
 from sage.rings.all import QQ, Integer
-from sage.interfaces.expect import is_ExpectElement
-from sage.interfaces.gap import GapElement
+from sage.interfaces.abc import ExpectElement, GapElement
 from sage.libs.gap.libgap import libgap
 from sage.libs.gap.element import GapElement as LibGapElement
 from sage.groups.perm_gps.permgroup_element import PermutationGroupElement
@@ -385,7 +384,7 @@ def PermutationGroup(gens=None, *args, **kwds):
         See https://trac.sagemath.org/31510 for details.
 
     """
-    if not is_ExpectElement(gens) and hasattr(gens, '_permgroup_'):
+    if not isinstance(gens, ExpectElement) and hasattr(gens, '_permgroup_'):
         return gens._permgroup_()
     if gens is not None and not isinstance(gens, (tuple, list, GapElement)):
         raise TypeError("gens must be a tuple, list, or GapElement")

src/sage/groups/perm_gps/permgroup_element.pyx

@@ -122,8 +122,9 @@ from sage.sets.finite_enumerated_set import FiniteEnumeratedSet
 import sage.structure.coerce as coerce
 from sage.structure.richcmp cimport richcmp_not_equal, rich_to_bool
 from sage.structure.coerce cimport coercion_model
-from sage.interfaces.gap import GapElement as PExpectGapElement
-from sage.interfaces.gp import GpElement
+from sage.interfaces.abc import GpElement
+
+import sage.interfaces.abc
 
 from sage.libs.gap.libgap import libgap
 from sage.libs.gap.gap_includes cimport (UInt, UInt2, UInt4, T_PERM2, T_PERM4,
@@ -478,7 +479,7 @@ cdef class PermutationGroupElement(MultiplicativeGroupElement):
                 self._set_list_images(g.sage(), convert)
             else:
                 raise ValueError("invalid data to initialize a permutation")
-        elif isinstance(g, PExpectGapElement):
+        elif isinstance(g, sage.interfaces.abc.GapElement):
             if g.IsPerm():
                 self._set_list_images(g.ListPerm(), False)
             else:

src/sage/interfaces/abc.py

@@ -1,3 +1,138 @@
+r"""
+Abstract base classes for interface elements
+"""
+
+class AxiomElement:
+    r"""
+    Abstract base class for :class:`~sage.interfaces.axiom.AxiomElement`.
+
+    This class is defined for the purpose of ``isinstance`` tests.  It should not be
+    instantiated.
+
+    EXAMPLES:
+
+    By design, there is a unique direct subclass::
+
+        sage: len(sage.interfaces.abc.AxiomElement.__subclasses__()) <= 1
+        True
+    """
+    pass
+
+
+class ExpectElement:
+    r"""
+    Abstract base class for :class:`~sage.interfaces.expect.ExpectElement`.
+
+    This class is defined for the purpose of ``isinstance`` tests.  It should not be
+    instantiated.
+
+    EXAMPLES:
+
+    By design, there is a unique direct subclass::
+
+        sage: len(sage.interfaces.abc.ExpectElement.__subclasses__()) <= 1
+        True
+    """
+    pass
+
+
+class FriCASElement:
+    r"""
+    Abstract base class for :class:`~sage.interfaces.fricas.FriCASElement`.
+
+    This class is defined for the purpose of ``isinstance`` tests.  It should not be
+    instantiated.
+
+    EXAMPLES:
+
+    By design, there is a unique direct subclass::
+
+        sage: len(sage.interfaces.abc.FriCASElement.__subclasses__()) <= 1
+        True
+    """
+    pass
+
+
 class GapElement:
+    r"""
+    Abstract base class for :class:`~sage.interfaces.gap.GapElement`.
+
+    This class is defined for the purpose of ``isinstance`` tests.  It should not be
+    instantiated.
+
+    EXAMPLES:
+
+    By design, there is a unique direct subclass::
+
+        sage: len(sage.interfaces.abc.GapElement.__subclasses__()) <= 1
+        True
+    """
+    pass
+
+
+class GpElement:
+    r"""
+    Abstract base class for :class:`~sage.interfaces.gp.GpElement`.
+
+    This class is defined for the purpose of ``isinstance`` tests.  It should not be
+    instantiated.
+
+    EXAMPLES:
+
+    By design, there is a unique direct subclass::
+
+        sage: len(sage.interfaces.abc.GpElement.__subclasses__()) <= 1
+        True
+    """
+    pass
+
+
+class Macaulay2Element:
+    r"""
+    Abstract base class for :class:`~sage.interfaces.macaulay2.Macaulay2Element`.
+
+    This class is defined for the purpose of ``isinstance`` tests.  It should not be
+    instantiated.
+
+    EXAMPLES:
+
+    By design, there is a unique direct subclass::
+
+        sage: len(sage.interfaces.abc.Macaulay2Element.__subclasses__()) <= 1
+        True
+    """
+    pass
+
+
+class MagmaElement:
+    r"""
+    Abstract base class for :class:`~sage.interfaces.magma.MagmaElement`.
+
+    This class is defined for the purpose of ``isinstance`` tests.  It should not be
+    instantiated.
+
+    EXAMPLES:
+
+    By design, there is a unique direct subclass::
+
+        sage: len(sage.interfaces.abc.MagmaElement.__subclasses__()) <= 1
+        True
+    """
+    pass
+
+
+class SingularElement:
+    r"""
+    Abstract base class for :class:`~sage.interfaces.singular.SingularElement`.
+
+    This class is defined for the purpose of ``isinstance`` tests.  It should not be
+    instantiated.
+
+    EXAMPLES:
+
+    By design, there is a unique direct subclass::
 
+        sage: len(sage.interfaces.abc.SingularElement.__subclasses__()) <= 1
+        True
+    """
     pass

src/sage/interfaces/axiom.py

@@ -179,6 +179,8 @@
 import os
 import re
 
+import sage.interfaces.abc
+
 from .expect import Expect, ExpectElement, FunctionElement, ExpectFunction
 from sage.env import DOT_SAGE
 from pexpect import EOF
@@ -555,7 +557,7 @@ def console(self):
 
 
 @instancedoc
-class PanAxiomElement(ExpectElement):
+class PanAxiomElement(ExpectElement, sage.interfaces.abc.AxiomElement):
     def __call__(self, x):
         """
         EXAMPLES::
@@ -944,18 +946,24 @@ def __init__(self, parent, name):
 
 def is_AxiomElement(x):
     """
-    Returns True of x is of type AxiomElement.
+    Return True if ``x`` is of type :class:`AxiomElement`.
 
     EXAMPLES::
 
         sage: from sage.interfaces.axiom import is_AxiomElement
-        sage: is_AxiomElement(axiom(2)) #optional - axiom
-        True
         sage: is_AxiomElement(2)
+        doctest:...: DeprecationWarning: the function is_AxiomElement is deprecated; use isinstance(x, sage.interfaces.abc.AxiomElement) instead
+        See https://trac.sagemath.org/34804 for details.
         False
+        sage: is_AxiomElement(axiom(2))  # optional - axiom
+        True
     """
+    from sage.misc.superseded import deprecation
+    deprecation(34804, "the function is_AxiomElement is deprecated; use isinstance(x, sage.interfaces.abc.AxiomElement) instead")
+
     return isinstance(x, AxiomElement)
 
+
 #Instances
 axiom = Axiom(name='axiom')
 

src/sage/interfaces/expect.py

@@ -52,6 +52,7 @@
 
 import pexpect
 from pexpect import ExceptionPexpect
+import sage.interfaces.abc
 from sage.interfaces.sagespawn import SageSpawn
 from sage.interfaces.interface import (Interface, InterfaceElement,
             InterfaceFunction, InterfaceFunctionElement)
@@ -1465,11 +1466,28 @@ class FunctionElement(InterfaceFunctionElement):
 
 
 def is_ExpectElement(x):
+    """
+    Return True if ``x`` is of type :class:`ExpectElement`
+
+    This function is deprecated; use :func:`isinstance`
+    (of :class:`sage.interfaces.abc.ExpectElement`) instead.
+
+    EXAMPLES::
+
+        sage: from sage.interfaces.expect import is_ExpectElement
+        sage: is_ExpectElement(2)
+        doctest:...: DeprecationWarning: the function is_ExpectElement is deprecated; use isinstance(x, sage.interfaces.abc.ExpectElement) instead
+        See https://trac.sagemath.org/34804 for details.
+        False
+    """
+    from sage.misc.superseded import deprecation
+    deprecation(34804, "the function is_ExpectElement is deprecated; use isinstance(x, sage.interfaces.abc.ExpectElement) instead")
+
     return isinstance(x, ExpectElement)
 
 
 @instancedoc
-class ExpectElement(InterfaceElement):
+class ExpectElement(InterfaceElement, sage.interfaces.abc.ExpectElement):
     """
     Expect element.
     """

src/sage/interfaces/fricas.py

@@ -198,6 +198,9 @@
 
 import re
 import os
+
+import sage.interfaces.abc
+
 from sage.interfaces.tab_completion import ExtraTabCompletion
 from sage.interfaces.expect import Expect, ExpectElement, FunctionElement, ExpectFunction
 from sage.env import DOT_SAGE, LOCAL_IDENTIFIER
@@ -995,7 +998,7 @@ def console(self):
 
 
 @instancedoc
-class FriCASElement(ExpectElement):
+class FriCASElement(ExpectElement, sage.interfaces.abc.FriCASElement):
     """
     Instances of this class represent objects in FriCAS.
 
@@ -2106,12 +2109,17 @@ def is_FriCASElement(x):
 
     EXAMPLES::
 
-        sage: from sage.interfaces.fricas import is_FriCASElement               # optional - fricas
+        sage: from sage.interfaces.fricas import is_FriCASElement
+        sage: is_FriCASElement(2)
+        doctest:...: DeprecationWarning: the function is_FriCASElement is deprecated; use isinstance(x, sage.interfaces.abc.FriCASElement) instead
+        See https://trac.sagemath.org/34804 for details.
+        False
         sage: is_FriCASElement(fricas(2))                                       # optional - fricas
         True
-        sage: is_FriCASElement(2)                                               # optional - fricas
-        False
     """
+    from sage.misc.superseded import deprecation
+    deprecation(34804, "the function is_FriCASElement is deprecated; use isinstance(x, sage.interfaces.abc.FriCASElement) instead")
+
     return isinstance(x, FriCASElement)
 
 
@@ -2120,8 +2128,7 @@ def is_FriCASElement(x):
 
 def reduce_load_fricas():
     """
-    Return the FriCAS interface object defined in
-    :sage.interfaces.fricas.
+    Return the FriCAS interface object defined in :mod:`sage.interfaces.fricas`.
 
     EXAMPLES::
 

src/sage/interfaces/gp.py

@@ -147,6 +147,7 @@
 from sage.libs.pari.all import pari
 import sage.rings.complex_mpfr
 from sage.misc.instancedoc import instancedoc
+import sage.interfaces.abc
 
 
 class Gp(ExtraTabCompletion, Expect):
@@ -821,7 +822,7 @@ def new_with_bits_prec(self, s, precision=0):
 
 
 @instancedoc
-class GpElement(ExpectElement):
+class GpElement(ExpectElement, sage.interfaces.abc.GpElement):
     """
     EXAMPLES: This example illustrates dumping and loading GP elements
     to compressed strings.
@@ -1036,16 +1037,24 @@ def _tab_completion(self):
 
 def is_GpElement(x):
     """
-    Returns True of x is a GpElement.
+    Return True if ``x`` is of type :class:`GpElement`
+
+    This function is deprecated; use :func:`isinstance`
+    (of :class:`sage.interfaces.abc.GpElement`) instead.
 
     EXAMPLES::
 
         sage: from sage.interfaces.gp import is_GpElement
         sage: is_GpElement(gp(2))
+        doctest:...: DeprecationWarning: the function is_GpElement is deprecated; use isinstance(x, sage.interfaces.abc.GpElement) instead
+        See https://trac.sagemath.org/34804 for details.
         True
         sage: is_GpElement(2)
         False
     """
+    from sage.misc.superseded import deprecation
+    deprecation(34804, "the function is_GpElement is deprecated; use isinstance(x, sage.interfaces.abc.GpElement) instead")
+
     return isinstance(x, GpElement)
 
 

src/sage/interfaces/interface.py

@@ -711,6 +711,20 @@ def _instancedoc_(self):
 
 
 def is_InterfaceElement(x):
+    """
+    Return True if ``x`` is of type :class:`InterfaceElement`.
+
+    EXAMPLES::
+
+        sage: from sage.interfaces.interface import is_InterfaceElement
+        sage: is_InterfaceElement(2)
+        doctest:...: DeprecationWarning: the function is_InterfaceElement is deprecated; use isinstance(x, sage.interfaces.abc.InterfaceElement) instead
+        See https://trac.sagemath.org/34804 for details.
+        False
+    """
+    from sage.misc.superseded import deprecation
+    deprecation(34804, "the function is_InterfaceElement is deprecated; use isinstance(x, sage.interfaces.abc.InterfaceElement) instead")
+
     return isinstance(x, InterfaceElement)
 
 

src/sage/interfaces/kash.py

@@ -784,6 +784,22 @@ def __repr__(self):
 
 
 def is_KashElement(x):
+    """
+    Returns True if ``x`` is of type :class:`KashElement`.
+
+    EXAMPLES::
+
+        sage: from sage.interfaces.kash import is_KashElement
+        sage: is_KashElement(2)
+        doctest:...: DeprecationWarning: the function is_KashElement is deprecated; use isinstance(x, sage.interfaces.abc.KashElement) instead
+        See https://trac.sagemath.org/34804 for details.
+        False
+        sage: is_KashElement(kash(2))  # optional - kash
+        True
+    """
+    from sage.misc.superseded import deprecation
+    deprecation(34804, "the function is_KashElement is deprecated; use isinstance(x, sage.interfaces.abc.KashElement) instead")
+
     return isinstance(x, KashElement)
 
 ######

src/sage/interfaces/lie.py

@@ -889,12 +889,17 @@ def is_LiEElement(x) -> bool:
     EXAMPLES::
 
         sage: from sage.interfaces.lie import is_LiEElement
+        sage: is_LiEElement(2)
+        doctest:...: DeprecationWarning: the function is_LiEElement is deprecated; use isinstance(x, sage.interfaces.abc.LiEElement) instead
+        See https://trac.sagemath.org/34804 for details.
+        False
         sage: l = lie(2) # optional - lie
         sage: is_LiEElement(l) # optional - lie
         True
-        sage: is_LiEElement(2)
-        False
     """
+    from sage.misc.superseded import deprecation
+    deprecation(34804, "the function is_LiEElement is deprecated; use isinstance(x, sage.interfaces.abc.LiEElement) instead")
+
     return isinstance(x, LiEElement)
 
 

src/sage/interfaces/lisp.py

@@ -525,11 +525,16 @@ def is_LispElement(x):
     EXAMPLES::
 
         sage: from sage.interfaces.lisp import is_LispElement
-        sage: is_LispElement(lisp(2))
-        True
         sage: is_LispElement(2)
+        doctest:...: DeprecationWarning: the function is_LispElement is deprecated; use isinstance(x, sage.interfaces.abc.LispElement) instead
+        See https://trac.sagemath.org/34804 for details.
         False
+        sage: is_LispElement(lisp(2))
+        True
     """
+    from sage.misc.superseded import deprecation
+    deprecation(34804, "the function is_LispElement is deprecated; use isinstance(x, sage.interfaces.abc.LispElement) instead")
+
     return isinstance(x, LispElement)
 
 # An instance

src/sage/interfaces/macaulay2.py

@@ -120,6 +120,8 @@
 import os
 import re
 
+import sage.interfaces.abc
+
 from sage.interfaces.expect import (Expect, ExpectElement, ExpectFunction,
                                     FunctionElement)
 from sage.interfaces.interface import AsciiArtString
@@ -867,7 +869,7 @@ def _macaulay2_input_ring(self, base_ring, vars, order='GRevLex'):
 
 
 @instancedoc
-class Macaulay2Element(ExtraTabCompletion, ExpectElement):
+class Macaulay2Element(ExtraTabCompletion, ExpectElement, sage.interfaces.abc.Macaulay2Element):
     """
     Instances of this class represent objects in Macaulay2.
 
@@ -1832,14 +1834,24 @@ def _sage_src_(self):
 
 def is_Macaulay2Element(x):
     """
+    Return True if ``x`` is a :class:`Macaulay2Element`
+
+    This function is deprecated; use :func:`isinstance`
+    (of :class:`sage.interfaces.abc.Macaulay2Element`) instead.
+
     EXAMPLES::
 
         sage: from sage.interfaces.macaulay2 import is_Macaulay2Element
         sage: is_Macaulay2Element(2)              # optional - macaulay2
+        doctest:...: DeprecationWarning: the function is_Macaulay2Element is deprecated; use isinstance(x, sage.interfaces.abc.MacaulayElement) instead
+        See https://trac.sagemath.org/34823 for details.
         False
         sage: is_Macaulay2Element(macaulay2(2))   # optional - macaulay2
         True
     """
+    from sage.misc.superseded import deprecation
+    deprecation(34804, "the function is_Macaulay2Element is deprecated; use isinstance(x, sage.interfaces.abc.Macaulay2Element) instead")
+
     return isinstance(x, Macaulay2Element)
 
 # An instance

src/sage/interfaces/magma.py

@@ -225,6 +225,7 @@
 from sage.env import SAGE_EXTCODE, DOT_SAGE
 import sage.misc.misc
 import sage.misc.sage_eval
+import sage.interfaces.abc
 from sage.interfaces.tab_completion import ExtraTabCompletion
 from sage.misc.instancedoc import instancedoc
 
@@ -1813,29 +1814,32 @@ def _instancedoc_(self):
 
 def is_MagmaElement(x):
     """
-    Return True if x is of type MagmaElement, and False otherwise.
+    Return True if ``x`` is of type :class:`MagmaElement`, and False otherwise.
 
     INPUT:
 
-
     -  ``x`` - any object
 
-
     OUTPUT: bool
 
     EXAMPLES::
 
         sage: from sage.interfaces.magma import is_MagmaElement
         sage: is_MagmaElement(2)
+        doctest:...: DeprecationWarning: the function is_MagmaElement is deprecated; use isinstance(x, sage.interfaces.abc.MagmaElement) instead
+        See https://trac.sagemath.org/34804 for details.
         False
         sage: is_MagmaElement(magma(2))                    # optional - magma
         True
     """
+    from sage.misc.superseded import deprecation
+    deprecation(34804, "the function is_MagmaElement is deprecated; use isinstance(x, sage.interfaces.abc.MagmaElement) instead")
+
     return isinstance(x, MagmaElement)
 
 
 @instancedoc
-class MagmaElement(ExtraTabCompletion, ExpectElement):
+class MagmaElement(ExtraTabCompletion, ExpectElement, sage.interfaces.abc.MagmaElement):
     def _ref(self):
         """
         Return a variable name that is a new reference to this particular

src/sage/interfaces/maxima.py

@@ -1125,17 +1125,22 @@ def _object_function_class(self):
 
 def is_MaximaElement(x):
     """
-    Returns True if x is of type MaximaElement.
+    Returns True if ``x`` is of type :class:`MaximaElement`.
 
     EXAMPLES::
 
         sage: from sage.interfaces.maxima import is_MaximaElement
+        sage: is_MaximaElement(1)
+        doctest:...: DeprecationWarning: the function is_MaximaElement is deprecated; use isinstance(x, sage.interfaces.abc.MaximaElement) instead
+        See https://trac.sagemath.org/34804 for details.
+        False
         sage: m = maxima(1)
         sage: is_MaximaElement(m)
         True
-        sage: is_MaximaElement(1)
-        False
     """
+    from sage.misc.superseded import deprecation
+    deprecation(34804, "the function is_MaximaElement is deprecated; use isinstance(x, sage.interfaces.abc.MaximaElement) instead")
+
     return isinstance(x, MaximaElement)
 
 

src/sage/interfaces/maxima_lib.py

@@ -1009,17 +1009,22 @@ def _missing_assumption(self,errstr):
 
 def is_MaximaLibElement(x):
     r"""
-    Returns True if x is of type MaximaLibElement.
+    Return True if ``x`` is of type :class:`MaximaLibElement`.
 
     EXAMPLES::
 
         sage: from sage.interfaces.maxima_lib import maxima_lib, is_MaximaLibElement
+        sage: is_MaximaLibElement(1)
+        doctest:...: DeprecationWarning: the function is_MaximaLibElement is deprecated; use isinstance(x, sage.interfaces.abc.MaximaLibElement) instead
+        See https://trac.sagemath.org/34804 for details.
+        False
         sage: m = maxima_lib(1)
         sage: is_MaximaLibElement(m)
         True
-        sage: is_MaximaLibElement(1)
-        False
     """
+    from sage.misc.superseded import deprecation
+    deprecation(34804, "the function is_MaximaLibElement is deprecated; use isinstance(x, sage.interfaces.abc.MaximaLibElement) instead")
+
     return isinstance(x, MaximaLibElement)
 
 

src/sage/interfaces/r.py

@@ -2001,10 +2001,15 @@ def is_RElement(x):
 
         sage: from sage.interfaces.r import is_RElement  # optional - rpy2
         sage: is_RElement(2)  # optional - rpy2
+        doctest:...: DeprecationWarning: the function is_RElement is deprecated; use isinstance(x, sage.interfaces.abc.RElement) instead
+        See https://trac.sagemath.org/34804 for details.
         False
         sage: is_RElement(r(2))  # optional - rpy2
         True
     """
+    from sage.misc.superseded import deprecation
+    deprecation(34804, "the function is_RElement is deprecated; use isinstance(x, sage.interfaces.abc.RElement) instead")
+
     return isinstance(x, RElement)
 
 # An instance of R

src/sage/interfaces/singular.py

@@ -345,6 +345,8 @@
 
 from .expect import Expect, ExpectElement, FunctionElement, ExpectFunction
 
+import sage.interfaces.abc
+
 from sage.interfaces.tab_completion import ExtraTabCompletion
 from sage.structure.sequence import Sequence_generic
 from sage.structure.element import RingElement
@@ -1355,7 +1357,7 @@ def _keyboard_interrupt(self):
 
 
 @instancedoc
-class SingularElement(ExtraTabCompletion, ExpectElement):
+class SingularElement(ExtraTabCompletion, ExpectElement, sage.interfaces.abc.SingularElement):
 
     def __init__(self, parent, type, value, is_name=False):
         """
@@ -2331,16 +2333,24 @@ def _instancedoc_(self):
 
 def is_SingularElement(x):
     r"""
-    Returns True is x is of type ``SingularElement``.
+    Return True is ``x`` is of type :class:`SingularElement`.
+
+    This function is deprecated; use :func:`isinstance`
+    (of :class:`sage.interfaces.abc.SingularElement`) instead.
 
     EXAMPLES::
 
         sage: from sage.interfaces.singular import is_SingularElement
         sage: is_SingularElement(singular(2))
+        doctest:...: DeprecationWarning: the function is_SingularElement is deprecated; use isinstance(x, sage.interfaces.abc.SingularElement) instead
+        See https://trac.sagemath.org/34804 for details.
         True
         sage: is_SingularElement(2)
         False
     """
+    from sage.misc.superseded import deprecation
+    deprecation(34804, "the function is_SingularElement is deprecated; use isinstance(x, sage.interfaces.abc.SingularElement) instead")
+
     return isinstance(x, SingularElement)
 
 

src/sage/rings/padics/padic_ZZ_pX_CA_element.pyx

@@ -178,7 +178,7 @@ from sage.libs.ntl.ntl_ZZ_pContext cimport ntl_ZZ_pContext_class
 from sage.libs.ntl.ntl_ZZ_pContext import ntl_ZZ_pContext
 from sage.rings.padics.padic_generic_element cimport pAdicGenericElement
 from sage.libs.pari.all import pari_gen
-from sage.interfaces.gp import GpElement
+from sage.interfaces.abc import GpElement
 from sage.rings.finite_rings.integer_mod import is_IntegerMod
 from sage.rings.finite_rings.integer_mod_ring import IntegerModRing
 from sage.rings.padics.padic_ext_element cimport pAdicExtElement

src/sage/rings/padics/padic_ZZ_pX_CR_element.pyx

@@ -204,7 +204,7 @@ from sage.libs.ntl.ntl_ZZ_pContext cimport ntl_ZZ_pContext_class
 from sage.libs.ntl.ntl_ZZ_pContext import ntl_ZZ_pContext
 from sage.rings.padics.padic_generic_element cimport pAdicGenericElement
 from sage.libs.pari.all import pari_gen
-from sage.interfaces.gp import GpElement
+from sage.interfaces.abc import GpElement
 from sage.rings.finite_rings.integer_mod import is_IntegerMod
 from sage.rings.padics.padic_ext_element cimport pAdicExtElement
 from sage.rings.padics.precision_error import PrecisionError

src/sage/rings/padics/padic_ZZ_pX_FM_element.pyx

@@ -147,7 +147,7 @@ from sage.libs.ntl.ntl_ZZ_pContext cimport ntl_ZZ_pContext_class
 from sage.libs.ntl.ntl_ZZ_pContext import ntl_ZZ_pContext
 from sage.rings.rational cimport Rational
 from sage.libs.pari.all import pari_gen
-from sage.interfaces.gp import GpElement
+from sage.interfaces.abc import GpElement
 from sage.rings.finite_rings.integer_mod import is_IntegerMod
 from sage.rings.finite_rings.integer_mod_ring import IntegerModRing
 from sage.rings.padics.pow_computer_ext cimport PowComputer_ZZ_pX_FM_Eis

src/sage/rings/polynomial/multi_polynomial_libsingular.pyx

@@ -249,8 +249,7 @@ from sage.structure.sequence import Sequence
 from sage.rings.fraction_field import FractionField
 from sage.rings.all import RealField
 
-from sage.interfaces.singular import singular as singular_default, is_SingularElement, SingularElement
-from sage.interfaces.macaulay2 import macaulay2 as macaulay2_default, is_Macaulay2Element
+import sage.interfaces.abc
 
 from sage.misc.misc_c import prod as mul
 from sage.misc.sage_eval import sage_eval
@@ -969,9 +968,9 @@ cdef class MPolynomialRing_libsingular(MPolynomialRing_base):
                 gens_map = dict(zip(Q.variable_names(),self.gens()[:Q.ngens()]))
                 return eval(str(element),gens_map)
 
-        if isinstance(element, (SingularElement, cypari2.gen.Gen)):
+        if isinstance(element, (sage.interfaces.abc.SingularElement, cypari2.gen.Gen)):
             element = str(element)
-        elif is_Macaulay2Element(element):
+        elif isinstance(element, sage.interfaces.abc.Macaulay2Element):
             element = element.external_string()
 
         if isinstance(element, str):
@@ -1106,10 +1105,7 @@ cdef class MPolynomialRing_libsingular(MPolynomialRing_base):
             if gens.ring() is self:
                 return gens
             gens = gens.gens()
-        if is_SingularElement(gens):
-            gens = list(gens)
-            coerce = True
-        elif is_Macaulay2Element(gens):
+        if isinstance(gens, (sage.interfaces.abc.SingularElement, sage.interfaces.abc.Macaulay2Element)):
             gens = list(gens)
             coerce = True
         if not isinstance(gens, (list, tuple)):
@@ -1118,7 +1114,7 @@ cdef class MPolynomialRing_libsingular(MPolynomialRing_base):
             gens = [self(x) for x in gens]  # this will even coerce from singular ideals correctly!
         return MPolynomialIdeal(self, gens, coerce=False)
 
-    def _macaulay2_(self, macaulay2=macaulay2_default):
+    def _macaulay2_(self, macaulay2=None):
         """
         Create an M2 representation of this polynomial ring if
         Macaulay2 is installed.
@@ -1147,6 +1143,8 @@ cdef class MPolynomialRing_libsingular(MPolynomialRing_base):
             --[x...y]
             17
         """
+        if macaulay2 is None:
+            from sage.interfaces.macaulay2 import macaulay2
         try:
             R = self.__macaulay2
             if R is None or not (R.parent() is macaulay2):
@@ -1165,18 +1163,18 @@ cdef class MPolynomialRing_libsingular(MPolynomialRing_base):
             'sage...[symbol x0,symbol x1, MonomialSize=>16, MonomialOrder=>GLex]'
         """
         if macaulay2 is None:
-            macaulay2 = macaulay2_default
+            from sage.interfaces.macaulay2 import macaulay2
         return macaulay2._macaulay2_input_ring(self.base_ring(), self.gens(),
                                                self.term_order().macaulay2_str())
 
-    def _singular_(self, singular=singular_default):
+    def _singular_(self, singular=None):
         """
         Create a SINGULAR (as in the computer algebra system)
         representation of this polynomial ring. The result is cached.
 
         INPUT:
 
-        - ``singular`` - SINGULAR interpreter (default: ``singular_default``)
+        - ``singular`` - SINGULAR interpreter (default: ``sage.interfaces.singular.singular``)
 
         EXAMPLES::
 
@@ -1222,6 +1220,8 @@ cdef class MPolynomialRing_libsingular(MPolynomialRing_base):
             //                  : names    x
             //        block   2 : ordering C
         """
+        if singular is None:
+            from sage.interfaces.singular import singular
         try:
             R = self.__singular
             if R is None or not (R.parent() is singular):
@@ -1241,15 +1241,15 @@ cdef class MPolynomialRing_libsingular(MPolynomialRing_base):
         except (AttributeError, ValueError):
             return self._singular_init_(singular)
 
-    def _singular_init_(self, singular=singular_default):
+    def _singular_init_(self, singular=None):
         """
         Create a SINGULAR (as in the computer algebra system)
         representation of this polynomial ring. The result is NOT
         cached.
 
         INPUT:
 
-        - ``singular`` - SINGULAR interpreter (default: ``singular_default``)
+        - ``singular`` - SINGULAR interpreter (default: ``sage.interfaces.singular.singular``)
 
         EXAMPLES::
 
@@ -1375,6 +1375,9 @@ cdef class MPolynomialRing_libsingular(MPolynomialRing_base):
         """
         from sage.functions.other import ceil
 
+        if singular is None:
+            from sage.interfaces.singular import singular
+
         if self.ngens()==1:
             _vars = str(self.gen())
             if "*" in _vars: # 1.000...000*x
@@ -5001,14 +5004,14 @@ cdef class MPolynomial_libsingular(MPolynomial):
             sig_off()
         return new_MP(parent, quo), new_MP(parent, rem)
 
-    def _singular_init_(self, singular=singular_default):
+    def _singular_init_(self, singular=None):
         """
         Return a SINGULAR (as in the computer algebra system) string
         representation for this element.
 
         INPUT:
 
-        - ``singular`` - interpreter (default: ``singular_default``)
+        - ``singular`` - interpreter (default: ``sage.interfaces.singular.singular``)
 
         EXAMPLES::
 
@@ -5023,6 +5026,8 @@ cdef class MPolynomial_libsingular(MPolynomial):
             sage: P(0)._singular_init_()
             '0'
         """
+        if singular is None:
+            from sage.interfaces.singular import singular
         self._parent._singular_().set_ring()
         return self._repr_short_()
 
@@ -5071,7 +5076,7 @@ cdef class MPolynomial_libsingular(MPolynomial):
 
         return new_MP(self._parent, p_Minus_mm_Mult_qq(p_Copy(self._poly, r), m._poly, q._poly, r))
 
-    def _macaulay2_(self, macaulay2=macaulay2_default):
+    def _macaulay2_(self, macaulay2=None):
         """
         Return a Macaulay2 element corresponding to this polynomial.
 
@@ -5110,6 +5115,8 @@ cdef class MPolynomial_libsingular(MPolynomial):
             sage: macaulay2(R('4')).ring()._operator('===', R)  # optional - macaulay2
             true
         """
+        if macaulay2 is None:
+            from sage.interfaces.macaulay2 import macaulay2
         m2_parent = macaulay2(self.parent())
         macaulay2.use(m2_parent)
         return macaulay2('substitute(%s,%s)' % (repr(self), m2_parent._name))

src/sage/rings/polynomial/multi_polynomial_ring.py

@@ -70,8 +70,8 @@
 from sage.rings.polynomial.polydict import PolyDict, ETuple
 from sage.rings.polynomial.term_order import TermOrder
 
-from sage.interfaces.singular import is_SingularElement
-from sage.interfaces.macaulay2 import is_Macaulay2Element
+import sage.interfaces.abc
+
 from sage.libs.pari.all import pari_gen
 
 from sage.structure.element import Element
@@ -489,7 +489,7 @@ def __call__(self, x=0, check=True):
             else:
                 raise TypeError("unable to coerce since the denominator is not 1")
 
-        elif is_SingularElement(x) and self._has_singular:
+        elif isinstance(x, sage.interfaces.abc.SingularElement) and self._has_singular:
             self._singular_().set_ring()
             try:
                 return x.sage_poly(self)
@@ -507,7 +507,7 @@ def __call__(self, x=0, check=True):
                 raise TypeError("unable to evaluate {!r} in {}".format(x, self))
             return self(x)
 
-        elif is_Macaulay2Element(x):
+        elif isinstance(x, sage.interfaces.abc.Macaulay2Element):
             try:
                 s = x.sage_polystring()
                 if len(s) == 0:
@@ -927,10 +927,7 @@ def ideal(self, *gens, **kwds):
         if not self._has_singular:
             # pass through
             MPolynomialRing_base.ideal(self, gens, **kwds)
-        if is_SingularElement(gens):
-            gens = list(gens)
-            do_coerce = True
-        if is_Macaulay2Element(gens):
+        if isinstance(gens, (sage.interfaces.abc.SingularElement, sage.interfaces.abc.Macaulay2Element)):
             gens = list(gens)
             do_coerce = True
         elif not isinstance(gens, (list, tuple)):

src/sage/rings/polynomial/pbori/pbori.pyx

@@ -217,8 +217,9 @@ from sage.categories.action cimport Action
 from sage.monoids.monoid import Monoid_class
 
 from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
-from sage.interfaces.singular import singular as singular_default
-from sage.interfaces.singular import SingularElement
+
+import sage.interfaces.abc
+
 
 order_dict = {"lp": pblp,
               "dlex": pbdlex,
@@ -997,7 +998,7 @@ cdef class BooleanPolynomialRing(MPolynomialRing_base):
                             m *= var_mapping[j]
                     p += m
             return p
-        elif isinstance(other, SingularElement):
+        elif isinstance(other, sage.interfaces.abc.SingularElement):
             other = str(other)
 
         if isinstance(other, str):
@@ -1428,7 +1429,7 @@ cdef class BooleanPolynomialRing(MPolynomialRing_base):
         G = R.gens()
         return R.ideal([x**2 + x for x in G])
 
-    def _singular_init_(self, singular=singular_default):
+    def _singular_init_(self, singular=None):
         r"""
         Return a newly created Singular quotient ring matching this boolean
         polynomial ring.

src/sage/rings/polynomial/polynomial_element.pyx

@@ -86,7 +86,6 @@ from sage.structure.factorization import Factorization
 from sage.structure.richcmp cimport (richcmp, richcmp_item,
         rich_to_bool, rich_to_bool_sgn)
 
-from sage.interfaces.singular import singular as singular_default, is_SingularElement
 from sage.libs.pari.all import pari, pari_gen, PariError
 
 cimport sage.rings.abc
@@ -99,6 +98,8 @@ from sage.rings.real_double import RDF
 from sage.rings.complex_double import CDF
 import sage.rings.abc
 
+import sage.interfaces.abc
+
 from sage.structure.coerce cimport coercion_model
 from sage.structure.element import coerce_binop
 from sage.structure.element cimport (parent, have_same_parent,

src/sage/rings/polynomial/polynomial_ring.py

@@ -177,7 +177,7 @@
 
 from . import cyclotomic
 
-from sage.interfaces.singular import SingularElement
+import sage.interfaces.abc
 
 
 def is_PolynomialRing(x):
@@ -435,13 +435,13 @@ def _element_constructor_(self, x=None, check=True, is_gen=False,
             elif P == self.base_ring():
                 return C(self, [x], check=True, is_gen=False,
                          construct=construct)
-        if isinstance(x, SingularElement) and self._has_singular:
+        if isinstance(x, sage.interfaces.abc.SingularElement) and self._has_singular:
             self._singular_().set_ring()
             try:
                 return x.sage_poly(self)
             except Exception:
                 raise TypeError("Unable to coerce singular object")
-        elif isinstance(x , str):
+        elif isinstance(x, str):
             try:
                 from sage.misc.parser import Parser, LookupNameMaker
                 R = self.base_ring()

src/sage/rings/power_series_ring.py

@@ -149,7 +149,7 @@
 import sage.misc.latex as latex
 from sage.structure.nonexact import Nonexact
 
-from sage.interfaces.magma import MagmaElement
+from sage.interfaces.abc import MagmaElement
 from sage.rings.fraction_field_element import FractionFieldElement
 from sage.misc.sage_eval import sage_eval
 

src/sage/rings/quotient_ring.py

@@ -115,17 +115,13 @@
 from sage.categories.rings import Rings
 from sage.categories.commutative_rings import CommutativeRings
 
+import sage.interfaces.abc
 
 _Rings = Rings()
 _CommRings = CommutativeRings()
 
 
 MPolynomialIdeal_quotient = None
-try:
-    from sage.interfaces.singular import singular as singular_default, is_SingularElement
-except ImportError:
-    is_singularElement = lambda x : False
-    singular_default = None
 
 
 def QuotientRing(R, I, names=None, **kwds):
@@ -959,7 +955,7 @@ def ideal(self, *gens, **kwds):
         if not (isinstance(self.__R, MPolynomialRing_base) and self.__R._has_singular):
             # pass through
             return super().ideal(gens, **kwds)
-        if is_SingularElement(gens):
+        if isinstance(gens, sage.interfaces.abc.SingularElement):
             gens = list(gens)
         elif not isinstance(gens, (list, tuple)):
             gens = [gens]
@@ -1015,7 +1011,7 @@ def _element_constructor_(self, x, coerce=True):
             if x.parent() is self:
                 return x
             x = x.lift()
-        if is_SingularElement(x):
+        if isinstance(x, sage.interfaces.abc.SingularElement):
             # self._singular_().set_ring()
             x = self.element_class(self, x.sage_poly(self.cover_ring()))
             return x
@@ -1181,7 +1177,7 @@ def gen(self, i=0):
         """
         return self(self.__R.gen(i))
 
-    def _singular_(self, singular=singular_default):
+    def _singular_(self, singular=None):
         """
         Returns the Singular quotient ring of ``self`` if the base ring is
         coercible to Singular.
@@ -1213,7 +1209,7 @@ def _singular_(self, singular=singular_default):
             _[1]=x2+y2
         """
         if singular is None:
-            raise ImportError("could not import singular")
+            from sage.interfaces.singular import singular
 
         try:
             Q = self.__singular