passagemath-environment 10.4.1__py3-none-any.whl

sage/features/interfaces.py

@@ -0,0 +1,256 @@
+# sage_setup: distribution = sagemath-environment
+r"""
+Features for testing whether interpreter interfaces to ``magma``, ``maple``, ``mathematica`` etc. are functional
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2021 Matthias Koeppe
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+import importlib
+
+from . import Feature, FeatureTestResult, PythonModule
+
+
+class InterfaceFeature(Feature):
+    r"""
+    A :class:`~sage.features.Feature` describing whether an :class:`~sage.interfaces.interface.Interface` is present and functional.
+
+    TESTS::
+
+        sage: from sage.features.interfaces import InterfaceFeature
+        sage: broken = InterfaceFeature("broken_interface", "sage.interfaces.does_not_exist")
+        sage: broken.is_present()
+        FeatureTestResult('sage.interfaces.does_not_exist', False)
+        sage: _.reason
+        "Failed to import `sage.interfaces.does_not_exist`: No module named 'sage.interfaces.does_not_exist'"
+
+        sage: also_broken = InterfaceFeature("also_broken_interface", "sage.interfaces.interface")
+        sage: also_broken.is_present()
+        FeatureTestResult('also_broken_interface', False)
+        sage: _.reason
+        "Interface also_broken_interface cannot be imported: module 'sage.interfaces.interface' has no attribute 'also_broken_interface'"
+    """
+    @staticmethod
+    def __classcall__(cls, name, module, description=None):
+        """
+        TESTS::
+
+            sage: from sage.features import PythonModule
+            sage: from sage.features.interfaces import InterfaceFeature
+            sage: f = InterfaceFeature("test_interface", "sage.interfaces.interface")
+            sage: f is InterfaceFeature("test_interface", PythonModule("sage.interfaces.interface"))
+            True
+        """
+        if isinstance(module, str):
+            module = PythonModule(module)
+        return Feature.__classcall__(cls, name, module, description)
+
+    def __init__(self, name, module, description):
+        """
+        TESTS::
+
+            sage: from sage.features.interfaces import InterfaceFeature
+            sage: f = InterfaceFeature("test_interface", "sage.interfaces.interface")
+            sage: isinstance(f, InterfaceFeature)
+            True
+        """
+        super().__init__(name, description=description)
+        self.module = module
+
+    def _is_present(self):
+        """
+        TESTS::
+
+            sage: from sage.features.interfaces import InterfaceFeature
+            sage: from sage.interfaces.sage0 import Sage
+            sage: f = InterfaceFeature("sage0", "sage.interfaces.sage0")
+            sage: f.is_present()
+            FeatureTestResult('sage0', True)
+        """
+        result = self.module.is_present()
+        if not result:
+            return result
+        m = importlib.import_module(self.module.name)
+        try:
+            interface = getattr(m, self.name)
+        except Exception as exception:
+            return FeatureTestResult(self, False,
+                                     reason=f"Interface {self.name} cannot be imported: {exception}")
+        try:
+            interface('2+3')
+            return FeatureTestResult(self, True)
+        except Exception as exception:
+            return FeatureTestResult(self, False,
+                                     reason=f"Interface {interface} is not functional: {exception}")
+
+
+class Mathics(InterfaceFeature):
+    r"""
+    A :class:`~sage.features.Feature` describing whether :class:`sage.interfaces.mathics.Mathics`
+    is present and functional.
+
+    EXAMPLES::
+
+        sage: from sage.features.interfaces import Mathics
+        sage: Mathics().is_present()  # not tested
+        FeatureTestResult('mathics', False)
+    """
+
+    @staticmethod
+    def __classcall__(cls):
+        return InterfaceFeature.__classcall__(cls, 'mathics', 'sage.interfaces.mathics')
+
+
+# The following are provided by external software only (no SPKG)
+
+class Magma(InterfaceFeature):
+    r"""
+    A :class:`~sage.features.Feature` describing whether :class:`sage.interfaces.magma.Magma`
+    is present and functional.
+
+    EXAMPLES::
+
+        sage: from sage.features.interfaces import Magma
+        sage: Magma().is_present()  # random
+        FeatureTestResult('magma', False)
+    """
+
+    @staticmethod
+    def __classcall__(cls):
+        return InterfaceFeature.__classcall__(cls, 'magma', 'sage.interfaces.magma')
+
+
+class Matlab(InterfaceFeature):
+    r"""
+    A :class:`~sage.features.Feature` describing whether :class:`sage.interfaces.matlab.Matlab`
+    is present and functional.
+
+    EXAMPLES::
+
+        sage: from sage.features.interfaces import Matlab
+        sage: Matlab().is_present()  # random
+        FeatureTestResult('matlab', False)
+    """
+
+    @staticmethod
+    def __classcall__(cls):
+        return InterfaceFeature.__classcall__(cls, 'matlab', 'sage.interfaces.matlab')
+
+
+class Mathematica(InterfaceFeature):
+    r"""
+    A :class:`~sage.features.Feature` describing whether :class:`sage.interfaces.mathematica.Mathematica`
+    is present and functional.
+
+    EXAMPLES::
+
+        sage: from sage.features.interfaces import Mathematica
+        sage: Mathematica().is_present()  # not tested
+        FeatureTestResult('mathematica', False)
+    """
+
+    @staticmethod
+    def __classcall__(cls):
+        return InterfaceFeature.__classcall__(cls, 'mathematica', 'sage.interfaces.mathematica')
+
+
+class Maple(InterfaceFeature):
+    r"""
+    A :class:`~sage.features.Feature` describing whether :class:`sage.interfaces.maple.Maple`
+    is present and functional.
+
+    EXAMPLES::
+
+        sage: from sage.features.interfaces import Maple
+        sage: Maple().is_present()  # random
+        FeatureTestResult('maple', False)
+    """
+
+    @staticmethod
+    def __classcall__(cls):
+        return InterfaceFeature.__classcall__(cls, 'maple', 'sage.interfaces.maple')
+
+
+class Macaulay2(InterfaceFeature):
+    r"""
+    A :class:`~sage.features.Feature` describing whether :class:`sage.interfaces.macaulay2.Macaulay2`
+    is present and functional.
+
+    EXAMPLES::
+
+        sage: from sage.features.interfaces import Macaulay2
+        sage: Macaulay2().is_present()  # random
+        FeatureTestResult('macaulay2', False)
+    """
+
+    @staticmethod
+    def __classcall__(cls):
+        return InterfaceFeature.__classcall__(cls, 'macaulay2', 'sage.interfaces.macaulay2')
+
+
+class Octave(InterfaceFeature):
+    r"""
+    A :class:`~sage.features.Feature` describing whether :class:`sage.interfaces.octave.Octave`
+    is present and functional.
+
+    EXAMPLES::
+
+        sage: from sage.features.interfaces import Octave
+        sage: Octave().is_present()  # random
+        FeatureTestResult('octave', False)
+    """
+
+    @staticmethod
+    def __classcall__(cls):
+        return InterfaceFeature.__classcall__(cls, 'octave', 'sage.interfaces.octave')
+
+
+class Scilab(InterfaceFeature):
+    r"""
+    A :class:`~sage.features.Feature` describing whether :class:`sage.interfaces.scilab.Scilab`
+    is present and functional.
+
+    EXAMPLES::
+
+        sage: from sage.features.interfaces import Scilab
+        sage: Scilab().is_present()  # random
+        FeatureTestResult('scilab', False)
+    """
+
+    @staticmethod
+    def __classcall__(cls):
+        return InterfaceFeature.__classcall__(cls, 'scilab', 'sage.interfaces.scilab')
+
+
+def all_features():
+    r"""
+    Return features corresponding to interpreter interfaces.
+
+    EXAMPLES::
+
+        sage: from sage.features.interfaces import all_features
+        sage: list(all_features())
+        [Feature('magma'),
+         Feature('matlab'),
+         Feature('mathematica'),
+         Feature('mathics'),
+         Feature('maple'),
+         Feature('macaulay2'),
+         Feature('octave'),
+         Feature('scilab')]
+    """
+    return [Magma(),
+            Matlab(),
+            Mathematica(),
+            Mathics(),
+            Maple(),
+            Macaulay2(),
+            Octave(),
+            Scilab()]

sage/features/internet.py

@@ -0,0 +1,65 @@
+# sage_setup: distribution = sagemath-environment
+r"""
+Feature for testing if the Internet is available
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2021 Matthias Koeppe
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from . import Feature, FeatureTestResult
+
+
+class Internet(Feature):
+    r"""
+    A :class:`~sage.features.Feature` describing if Internet is available.
+
+    Failure of connecting to the site "https://www.sagemath.org" within a second
+    is regarded as internet being not available.
+
+    EXAMPLES::
+
+        sage: from sage.features.internet import Internet
+        sage: Internet()
+        Feature('internet')
+    """
+    def __init__(self):
+        r"""
+        TESTS::
+
+            sage: from sage.features.internet import Internet
+            sage: Internet() is Internet()
+            True
+        """
+        Feature.__init__(self, 'internet')
+
+    def _is_present(self):
+        r"""
+        Test whether Internet is available.
+
+        EXAMPLES::
+
+            sage: from sage.features.internet import Internet
+            sage: Internet()._is_present()  # random, optional - internet
+            FeatureTestResult('internet', True)
+        """
+        import urllib.error
+        from urllib.request import Request, urlopen
+        from ssl import create_default_context as default_context
+
+        req = Request("https://www.sagemath.org", headers={"User-Agent": "sage-doctest"})
+        try:
+            urlopen(req, timeout=1, context=default_context())
+            return FeatureTestResult(self, True)
+        except (urllib.error.URLError, TimeoutError):
+            return FeatureTestResult(self, False)
+
+
+def all_features():
+    return [Internet()]

sage/features/jmol.py

@@ -0,0 +1,44 @@
+# sage_setup: distribution = sagemath-environment
+import os
+
+from . import StaticFile
+
+
+class JmolDataJar(StaticFile):
+    r"""
+    A :class:`~sage.features.Feature` which describes the presence of
+    JmolData.jar in a few standard locations.
+
+    EXAMPLES::
+
+        sage: from sage.features.jmol import JmolDataJar
+        sage: bool(JmolDataJar().is_present())  # needs jmol
+        True
+    """
+
+    def __init__(self):
+        r"""
+        TESTS::
+
+            sage: from sage.features.jmol import JmolDataJar
+            sage: isinstance(JmolDataJar(), JmolDataJar)
+            True
+        """
+        from sage.env import SAGE_SHARE, JMOL_DIR
+
+        jmol_search_path = JMOL_DIR or (
+                os.path.join(SAGE_SHARE, "sagemath", "jmol"),
+                os.path.join(SAGE_SHARE, "jmol")
+                )
+
+        StaticFile.__init__(
+            self, name='jmol',
+            filename='JmolData.jar',
+            search_path=jmol_search_path,
+            spkg='jmol',
+            type='optional',
+            description="Java viewer for chemical structures in 3D")
+
+
+def all_features():
+    return [JmolDataJar()]

sage/features/join_feature.py

@@ -0,0 +1,146 @@
+# sage_setup: distribution = sagemath-environment
+r"""
+Join features
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2021-2022 Matthias Koeppe
+#                     2021-2022 Kwankyu Lee
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+from . import Feature, FeatureTestResult
+
+
+class JoinFeature(Feature):
+    r"""
+    Join of several :class:`~sage.features.Feature` instances.
+
+    This creates a new feature as the union of the given features. Typically
+    these are executables of an SPKG. For an example, see
+    :class:`~sage.features.rubiks.Rubiks`.
+
+    Furthermore, this can be the union of a single feature. This is used to map
+    the given feature to a more convenient name to be used in ``optional`` tags
+    of doctests. Thus you can equip a feature such as a
+    :class:`~sage.features.PythonModule` with a tag name that differs from the
+    systematic tag name. As an example for this use case, see
+    :class:`~sage.features.meataxe.Meataxe`.
+
+    EXAMPLES::
+
+        sage: from sage.features import Executable
+        sage: from sage.features.join_feature import JoinFeature
+        sage: F = JoinFeature("shell-boolean",
+        ....:                 (Executable('shell-true', 'true'),
+        ....:                  Executable('shell-false', 'false')))
+        sage: F.is_present()
+        FeatureTestResult('shell-boolean', True)
+        sage: F = JoinFeature("asdfghjkl",
+        ....:                 (Executable('shell-true', 'true'),
+        ....:                  Executable('xxyyyy', 'xxyyyy-does-not-exist')))
+        sage: F.is_present()
+        FeatureTestResult('xxyyyy', False)
+    """
+
+    def __init__(self, name, features, spkg=None, url=None, description=None, type=None,
+                 **kwds):
+        """
+        TESTS:
+
+        The empty join feature is present::
+
+            sage: from sage.features.join_feature import JoinFeature
+            sage: JoinFeature("empty", ()).is_present()
+            FeatureTestResult('empty', True)
+        """
+        if spkg is None:
+            spkgs = set(f.spkg for f in features if f.spkg)
+            if len(spkgs) > 1:
+                raise ValueError('given features have more than one spkg; provide spkg argument')
+            elif len(spkgs) == 1:
+                spkg = next(iter(spkgs))
+        if url is None:
+            urls = set(f.url for f in features if f.url)
+            if len(urls) > 1:
+                raise ValueError('given features have more than one url; provide url argument')
+            elif len(urls) == 1:
+                url = next(iter(urls))
+        if type is None:
+            if any(f._spkg_type() == 'experimental' for f in features):
+                type = 'experimental'
+            elif any(f._spkg_type() == 'optional' for f in features):
+                type = 'optional'
+            else:
+                type = 'standard'
+
+        super().__init__(name, spkg=spkg, url=url, description=description, type=type, **kwds)
+        self._features = features
+
+    def _is_present(self):
+        r"""
+        Test for the presence of the join feature.
+
+        EXAMPLES::
+
+            sage: from sage.features.latte import Latte
+            sage: Latte()._is_present()  # optional - latte_int
+            FeatureTestResult('latte_int', True)
+        """
+        for f in self._features:
+            test = f._is_present()
+            if not test:
+                return test
+        return FeatureTestResult(self, True)
+
+    def hide(self):
+        r"""
+        Hide this feature and all its joined features.
+
+        EXAMPLES::
+
+            sage: from sage.features.sagemath import sage__groups
+            sage: f = sage__groups()
+            sage: f.hide()
+            sage: f._features[0].is_present()
+            FeatureTestResult('sage.groups.perm_gps.permgroup', False)
+
+            sage: f.require()
+            Traceback (most recent call last):
+            ...
+            FeatureNotPresentError: sage.groups is not available.
+            Feature `sage.groups` is hidden.
+            Use method `unhide` to make it available again.
+        """
+        for f in self._features:
+            f.hide()
+        super().hide()
+
+    def unhide(self):
+        r"""
+        Revert what :meth:`hide` did.
+
+        EXAMPLES::
+
+            sage: from sage.features.sagemath import sage__groups
+            sage: f = sage__groups()
+            sage: f.hide()
+            sage: f.is_present()
+            FeatureTestResult('sage.groups', False)
+            sage: f._features[0].is_present()
+            FeatureTestResult('sage.groups.perm_gps.permgroup', False)
+
+            sage: f.unhide()
+            sage: f.is_present()    # optional sage.groups
+            FeatureTestResult('sage.groups', True)
+            sage: f._features[0].is_present() # optional sage.groups
+            FeatureTestResult('sage.groups.perm_gps.permgroup', True)
+        """
+        for f in self._features:
+            f.unhide()
+        super().unhide()

sage/features/kenzo.py

@@ -0,0 +1,77 @@
+# sage_setup: distribution = sagemath-environment
+r"""
+Feature for testing the presence of ``kenzo``
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2020 Travis Scrimshaw
+#                     2021 Matthias Koeppe
+#                     2021 Michael Orlitzky
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+
+from . import Feature, FeatureTestResult
+
+class Kenzo(Feature):
+    r"""
+    A :class:`~sage.features.Feature` describing the presence of :ref:`Kenzo <spkg_kenzo>`.
+
+    EXAMPLES::
+
+        sage: from sage.features.kenzo import Kenzo
+        sage: Kenzo().is_present()  # optional - kenzo
+        FeatureTestResult('kenzo', True)
+    """
+    def __init__(self):
+        r"""
+        TESTS::
+
+            sage: from sage.features.kenzo import Kenzo
+            sage: isinstance(Kenzo(), Kenzo)
+            True
+        """
+        Feature.__init__(self, name='kenzo', spkg='kenzo',
+                         url='https://github.com/miguelmarco/kenzo/')
+
+    def _is_present(self):
+        r"""
+        Check whether Kenzo is installed and works.
+
+        EXAMPLES::
+
+            sage: from sage.features.kenzo import Kenzo
+            sage: Kenzo()._is_present()  # optional - kenzo
+            FeatureTestResult('kenzo', True)
+        """
+        try:
+            from sage.libs.ecl import ecl_eval
+        except ImportError:
+            return FeatureTestResult(self, False, reason="sage.libs.ecl is not available")
+        # Redirection of ECL and Maxima stdout to /dev/null
+        # This is also done in the Maxima library, but we
+        # also do it here for redundancy.
+        ecl_eval(r"""(defparameter *dev-null* (make-two-way-stream
+                      (make-concatenated-stream) (make-broadcast-stream)))""")
+        ecl_eval("(setf original-standard-output *standard-output*)")
+        ecl_eval("(setf *standard-output* *dev-null*)")
+
+        try:
+            from sage.env import KENZO_FAS
+            if KENZO_FAS:
+                ecl_eval("(require :kenzo \"{}\")".format(KENZO_FAS))
+            else:
+                ecl_eval("(require :kenzo)")
+
+        except RuntimeError:
+            return FeatureTestResult(self, False, reason="Unable to make ECL require kenzo")
+        return FeatureTestResult(self, True)
+
+
+def all_features():
+    return [Kenzo()]