passagemath-repl 10.4.62__py3-none-any.whl

sage/interfaces/cleaner.py

@@ -0,0 +1,48 @@
+# sage_setup: distribution = sagemath-repl
+"""
+Interface to the Sage cleaner
+
+Triva Note: For the name "sage-cleaner", think of the
+"The Cleaner" from Pulp Fiction:
+http://www.frankjankowski.de/quiz/illus/keitel.jpg
+"""
+# ****************************************************************************
+#       Copyright (C) 2007 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  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 os
+import atexit
+import tempfile
+
+_spd = tempfile.TemporaryDirectory()
+SAGE_SPAWNED_PROCESS_FILE = os.path.join(_spd.name, "spawned_processes")
+atexit.register(lambda: _spd.cleanup())
+
+
+def start_cleaner():
+    """
+    Start ``sage-cleaner`` in a new process group.
+    """
+    if not os.fork():
+        os.setpgid(os.getpid(), os.getpid())
+
+        # Redirect stdin, stdout, stderr to /dev/null
+        with open(os.devnull, "r+") as f:
+            os.dup2(f.fileno(), 0)
+            os.dup2(f.fileno(), 1)
+            os.dup2(f.fileno(), 2)
+
+        # Close all other file descriptors
+        try:
+            maxopenfiles = os.sysconf("SC_OPEN_MAX")
+            if maxopenfiles <= 0:
+                raise ValueError
+        except ValueError:
+            maxopenfiles = 1024
+        os.closerange(3, maxopenfiles)
+
+        os.execlp("sage-cleaner", "sage-cleaner")

sage/interfaces/quit.py

@@ -0,0 +1,163 @@
+# sage_setup: distribution = sagemath-repl
+"""
+Quitting interfaces
+"""
+
+################################################################################
+#       Copyright (C) 2010 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of (any version of) the GNU
+#  General Public License (GPL). The full text of the GPL is available at:
+#
+#                  https://www.gnu.org/licenses/
+################################################################################
+
+import os
+
+from sage.misc.cachefunc import cached_function
+
+
+@cached_function
+def sage_spawned_process_file():
+    """
+    EXAMPLES::
+
+        sage: from sage.interfaces.quit import sage_spawned_process_file
+        sage: len(sage_spawned_process_file()) > 1
+        True
+    """
+    # This is the old value of SAGE_TMP. Until sage-cleaner is
+    # completely removed, we need to leave these spawned_processes
+    # files where sage-cleaner will look for them.
+    from sage.env import DOT_SAGE, HOSTNAME
+    d = os.path.join(DOT_SAGE, "temp", HOSTNAME, str(os.getpid()))
+    os.makedirs(d, exist_ok=True)
+    return os.path.join(d, "spawned_processes")
+
+
+def register_spawned_process(pid, cmd=''):
+    """
+    Write a line to the ``spawned_processes`` file with the given
+    ``pid`` and ``cmd``.
+    """
+    if cmd != '':
+        cmd = cmd.strip().split()[0]
+    # This is safe, since only this process writes to this file.
+    try:
+        with open(sage_spawned_process_file(), 'a') as o:
+            o.write('%s %s\n' % (pid, cmd))
+    except OSError:
+        pass
+    else:
+        # If sage is being used as a python library, we need to launch
+        # the cleaner ourselves upon being told that there will be
+        # something to clean.
+        from sage.interfaces.cleaner import start_cleaner
+        start_cleaner()
+
+
+expect_objects = []
+
+
+def expect_quitall(verbose=False):
+    """
+    EXAMPLES::
+
+        sage: sage.interfaces.quit.expect_quitall()
+        sage: gp.eval('a=10')                                                           # needs sage.libs.pari
+        '10'
+        sage: gp('a')                                                                   # needs sage.libs.pari
+        10
+        sage: sage.interfaces.quit.expect_quitall()
+        sage: gp('a')                                                                   # needs sage.libs.pari
+        a
+        sage: sage.interfaces.quit.expect_quitall(verbose=True)                         # needs sage.libs.pari
+        Exiting PARI/GP interpreter with PID ... running .../gp --fast --emacs --quiet --stacksize 10000000
+    """
+    for P in expect_objects:
+        R = P()
+        if R is not None:
+            try:
+                R.quit(verbose=verbose)
+            except RuntimeError:
+                pass
+    kill_spawned_jobs()
+
+
+def kill_spawned_jobs(verbose=False):
+    """
+    INPUT:
+
+    - ``verbose`` -- boolean (default: ``False``); if ``True``, display a
+      message each time a process is sent a kill signal
+
+    EXAMPLES::
+
+        sage: gp.eval('a=10')                                                           # needs sage.libs.pari
+        '10'
+        sage: sage.interfaces.quit.kill_spawned_jobs(verbose=False)
+        sage: sage.interfaces.quit.expect_quitall()
+        sage: gp.eval('a=10')                                                           # needs sage.libs.pari
+        '10'
+        sage: sage.interfaces.quit.kill_spawned_jobs(verbose=True)                      # needs sage.libs.pari
+        Killing spawned job ...
+
+    After doing the above, we do the following to avoid confusion in other doctests::
+
+        sage: sage.interfaces.quit.expect_quitall()
+    """
+    fname = sage_spawned_process_file()
+    if not os.path.exists(fname):
+        return
+
+    with open(fname) as f:
+        for L in f:
+            i = L.find(' ')
+            pid = L[:i].strip()
+            try:
+                if verbose:
+                    print("Killing spawned job %s" % pid)
+                os.killpg(int(pid), 9)
+            except OSError:
+                pass
+
+
+def is_running(pid):
+    """
+    Return ``True`` if and only if there is a process with id pid running.
+    """
+    try:
+        os.kill(int(pid), 0)
+        return True
+    except (OSError, ValueError):
+        return False
+
+
+def invalidate_all():
+    """
+    Invalidate all of the expect interfaces.
+
+    This is used, e.g., by the fork-based @parallel decorator.
+
+    EXAMPLES::
+
+        sage: # needs sage.libs.pari sage.symbolic
+        sage: a = maxima(2); b = gp(3)
+        sage: a, b
+        (2, 3)
+        sage: sage.interfaces.quit.invalidate_all()
+        sage: a
+        (invalid Maxima object -- The maxima session in which this object was defined is no longer running.)
+        sage: b
+        (invalid PARI/GP interpreter object -- The pari session in which this object was defined is no longer running.)
+
+    However the maxima and gp sessions should still work out, though with their state reset::
+
+        sage: a = maxima(2); b = gp(3)                                                  # needs sage.libs.pari sage.symbolic
+        sage: a, b                                                                      # needs sage.libs.pari sage.symbolic
+        (2, 3)
+    """
+    for I in expect_objects:
+        I1 = I()
+        if I1:
+            I1.detach()

sage/misc/all__sagemath_repl.py

@@ -0,0 +1,51 @@
+# sage_setup: distribution = sagemath-repl
+
+from sage.misc.all__sagemath_objects import *
+
+from sage.misc.sage_eval import sage_eval, sageobj
+
+from sage.misc.sage_input import sage_input
+
+from sage.misc.banner import version
+
+lazy_import('sage.misc.banner', 'banner', deprecation=34259)
+
+lazy_import('sage.misc.sagedoc', ['browse_sage_doc',
+                                  'search_src', 'search_def', 'search_doc',
+                                  'tutorial', 'reference', 'manual', 'developer',
+                                  'constructions', 'help'])
+
+lazy_import('pydoc', 'help', 'python_help')
+
+from sage.misc.explain_pickle import (explain_pickle, unpickle_newobj, unpickle_build,
+                                      unpickle_instantiate, unpickle_persistent,
+                                      unpickle_extension, unpickle_appends)
+
+lazy_import('sage.misc.trace', 'trace', deprecation=34259)
+
+lazy_import('sage.misc.profiler', 'Profiler', deprecation=34259)
+
+lazy_import('sage.misc.classgraph', 'class_graph')
+
+from sage.misc.dev_tools import import_statements
+
+lazy_import('sage.misc.dev_tools', 'runsnake', deprecation=34259)
+
+from sage.misc.edit_module import edit
+
+lazy_import('sage.misc.edit_module', 'set_edit_template', deprecation=34259)
+
+lazy_import('sage.misc.pager', 'pager')
+
+lazy_import('sage.misc.remote_file', 'get_remote_file')
+
+lazy_import('sage.misc.sh', 'sh')
+
+lazy_import("sage.misc.cython", "cython_lambda")
+lazy_import("sage.misc.cython", "cython_compile", "cython")
+lazy_import('sage.misc.inline_fortran', 'fortran')
+
+lazy_import('sage.misc.package', ('installed_packages', 'is_package_installed',
+                                  'package_versions'),
+            deprecation=34259)
+lazy_import('sage.misc.benchmark', 'benchmark', deprecation=34259)

sage/misc/banner.py

@@ -0,0 +1,235 @@
+# sage_setup: distribution = sagemath-repl
+r"""
+SageMath version and banner info
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2005 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#  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 sys
+
+from sage.env import (SAGE_VERSION, SAGE_VERSION_BANNER, SAGE_BANNER)
+
+
+def version():
+    """
+    Return the version of Sage.
+
+    OUTPUT: string
+
+    EXAMPLES::
+
+       sage: version()
+       '... version ..., Release Date: ...'
+    """
+    return SAGE_VERSION_BANNER
+
+
+def banner_text(full=True):
+    """
+    Text for the Sage banner.
+
+    INPUT:
+
+    - ``full`` -- boolean (default: ``True``)
+
+    OUTPUT:
+
+    A string containing the banner message.
+
+    If option full is ``False``, a simplified plain ASCII banner is
+    displayed; if ``True`` the full banner with box art is displayed.
+
+    EXAMPLES::
+
+        sage: print(sage.misc.banner.banner_text(full=True))
+        ┌────────────────────────────────────────────────────────────────────┐
+        │ ... version ...
+        sage: print(sage.misc.banner.banner_text(full=False))
+        ... version ..., Release Date: ...
+    """
+    if not full:
+        return version()
+
+    bars = "─" * 68
+    s = []
+    a = s.append
+    a('┌' + bars + '┐')
+    a("\n│ %-66s │\n" % version())
+    python_version = sys.version_info[:3]
+    a("│ %-66s │\n" % 'Using Python {}.{}.{}. Type "help()" for help.'.format(*python_version))
+    a('└' + bars + '┘')
+    pre = version_dict()['prerelease']
+    try:
+        import sage.all
+        have_sage_all = True
+    except ImportError:
+        have_sage_all = False
+    if pre or not have_sage_all:
+        red_in = '\033[31m'
+        red_out = '\033[0m'
+        bars2 = bars.replace('─', '━')
+        a('\n')
+        a(red_in + '┏' + bars2 + '┓' + '\n')
+        if pre:
+            a("┃ %-66s ┃\n" % 'Warning: this is a prerelease version, and it may be unstable.')
+        if not have_sage_all:
+            a("┃ %-66s ┃\n" % 'Warning: sage.all is not available; this is a limited REPL.')
+        a('┗' + bars2 + '┛' + red_out)
+    return ''.join(s)
+
+
+def banner():
+    """
+    Print the Sage banner.
+
+    OUTPUT: none
+
+    If the environment variable ``SAGE_BANNER`` is set to ``no``, no
+    banner is displayed. If ``SAGE_BANNER`` is set to ``bare``, a
+    simplified plain ASCII banner is displayed. Otherwise, the full
+    banner with box art is displayed.
+
+    EXAMPLES::
+
+        sage: import sage.misc.banner; sage.misc.banner.SAGE_BANNER = ''
+        sage: sage.misc.banner.banner()
+        ┌────────────────────────────────────────────────────────────────────┐
+        │ ... version ..., Release Date: ...                                 │
+        │ Using Python .... Type "help()" for help.                          │
+        ...
+    """
+    typ = SAGE_BANNER.lower()
+
+    if typ == "no":
+        return
+
+    if typ != "bare":
+        try:
+            print(banner_text(full=True))
+            return
+        except UnicodeEncodeError:
+            pass
+
+    print(banner_text(full=False))
+
+
+def version_dict():
+    """
+    A dictionary describing the version of Sage.
+
+    OUTPUT: dictionary with keys 'major', 'minor', 'tiny', 'prerelease'
+
+    This process the Sage version string and produces a dictionary.
+    It expects the Sage version to be in one of these forms::
+
+       N.N
+       N.N.N
+       N.N.N.N
+       N.N.str
+       N.N.N.str
+       N.N.N.N.str
+
+    where 'N' stands for an integer and 'str' stands for a string.
+    The first integer is stored under the 'major' key and the second
+    integer under 'minor'.  If there is one more integer, it is stored
+    under 'tiny'; if there are two more integers, then they are stored
+    together as a float N.N under 'tiny'.  If there is a string, then
+    the key 'prerelease' returns True.
+
+    For example, if the Sage version is '3.2.1', then the dictionary
+    is {'major': 3, 'minor': 2, 'tiny': 1, 'prerelease': False}.
+    If the Sage version is '3.2.1.2', then the dictionary is
+    {'major': 3, 'minor': 2, 'tiny': 1.200..., 'prerelease': False}.
+    If the Sage version is '3.2.alpha0', then the dictionary is
+    {'major': 3, 'minor': 2, 'tiny': 0, 'prerelease': True}.
+
+    EXAMPLES::
+
+        sage: from sage.misc.banner import version_dict
+        sage: print("SageMath major version is %s" % version_dict()['major'])
+        SageMath major version is ...
+        sage: version_dict()['major'] == int(sage.version.version.split('.')[0])
+        True
+    """
+    v = SAGE_VERSION.split('.')
+    dict = {}
+    dict['major'] = int(v[0])
+    dict['minor'] = int(v[1])
+    dict['tiny'] = 0
+    dict['prerelease'] = False
+    try:
+        int(v[-1])
+    except ValueError:  # when last entry is not an integer
+        dict['prerelease'] = True
+    if (len(v) == 3 and not dict['prerelease']) or len(v) > 3:
+        dict['tiny'] = int(v[2])
+    try:
+        teeny = int(v[3])
+        dict['tiny'] += 0.1 * teeny
+    except (ValueError, IndexError):
+        pass
+    return dict
+
+
+def require_version(major, minor=0, tiny=0, prerelease=False,
+                    print_message=False):
+    """
+    Return ``True`` if Sage version is at least ``major.minor.tiny``.
+
+    INPUT:
+
+    - ``major`` -- integer
+    - ``minor`` -- integer (default: 0)
+    - ``tiny`` -- float (default: 0)
+    - ``prerelease`` -- boolean (default: ``False``)
+    - ``print_message`` -- boolean (default: ``False``)
+
+    OUTPUT: ``True`` if ``major.minor.tiny`` is <= version of Sage, ``False``
+    otherwise
+
+    For example, if the Sage version number is 3.1.2, then
+    require_version(3, 1, 3) will return False, while
+    require_version(3, 1, 2) will return True.
+    If the Sage version is 3.1.2.alpha0, then
+    require_version(3, 1, 1) will return True, while, by default,
+    require_version(3, 1, 2) will return False.  Note, though, that
+    require_version(3, 1, 2, prerelease=True) will return True:
+    if the optional argument prerelease is True, then a prerelease
+    version of Sage counts as if it were the released version.
+
+    If optional argument print_message is ``True`` and this function
+    is returning False, print a warning message.
+
+    EXAMPLES::
+
+        sage: from sage.misc.banner import require_version
+        sage: require_version(2, 1, 3)
+        True
+        sage: require_version(821, 4)
+        False
+        sage: require_version(821, 4, print_message=True)
+        This code requires at least version 821.4 of SageMath to run correctly.
+        You are running version ...
+        False
+    """
+    vers = version_dict()
+    prerelease_checked = (prerelease if vers['prerelease'] else True)
+    if (vers['major'] > major
+        or (vers['major'] == major and vers['minor'] > minor)
+        or (vers['major'] == major and vers['minor'] == minor
+            and vers['tiny'] > tiny)
+        or (vers['major'] == major and vers['minor'] == minor
+            and vers['tiny'] == tiny and prerelease_checked)):
+        return True
+    else:
+        if print_message:
+            txt = "This code requires at least version {} of SageMath to run correctly."
+            print(txt.format(major + 0.1 * minor + 0.01 * tiny))
+            print("You are running version {}.".format(SAGE_VERSION))
+        return False