passagemath-repl 10.5.1__py3-none-any.whl

sage/misc/gperftools.py

@@ -0,0 +1,361 @@
+# sage_setup: distribution = sagemath-repl
+# sage.doctest: needs sage.symbolic
+"""
+C Function Profiler Using Google Perftools
+
+Note that the profiler samples 100x per second by default. In
+particular, you cannot profile anything shorter than 10ms. You can
+adjust the rate with the ``CPUPROFILE_FREQUENCY`` environment variable
+if you want to change it.
+
+EXAMPLES::
+
+    sage: from sage.misc.gperftools import Profiler, run_100ms
+    sage: prof = Profiler()
+    sage: prof.start()       # optional - gperftools
+    sage: run_100ms()
+    sage: prof.stop()        # optional - gperftools
+    PROFILE: interrupts/evictions/bytes = ...
+
+REFERENCE:
+
+Uses the `Google performance analysis tools
+<https://github.com/gperftools/gperftools>`_. Note that they are not
+included in Sage, you have to install them yourself on your system.
+
+AUTHORS:
+
+- Volker Braun (2014-03-31): initial version
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2014 Volker Braun <vbraun.name@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+import sys
+import ctypes
+import time
+from sage.structure.sage_object import SageObject
+from sage.misc.cachefunc import cached_method
+from sage.misc.compat import find_library
+from sage.cpython.string import bytes_to_str
+
+
+libc = None
+libprofiler = None
+
+
+class Profiler(SageObject):
+
+    def __init__(self, filename=None):
+        """
+        Interface to the gperftools profiler.
+
+        INPUT:
+
+        - ``filename`` -- string or ``None`` (default). The file name
+          to log to. By default, a new temporary file is created.
+
+        EXAMPLES::
+
+            sage: from sage.misc.gperftools import Profiler
+            sage: Profiler()
+            Profiler logging to ...
+        """
+        if filename is None:
+            from sage.misc.temporary_file import tmp_filename
+            self._filename = tmp_filename(ext='.perf')
+        else:
+            self._filename = filename
+
+    def filename(self):
+        """
+        Return the file name.
+
+        OUTPUT: string
+
+        EXAMPLES::
+
+            sage: from sage.misc.gperftools import Profiler
+            sage: prof = Profiler()
+            sage: prof.filename()
+            '.../tmp_....perf'
+        """
+        return self._filename
+
+    def _repr_(self):
+        """
+        Return string representation.
+
+        OUTPUT: string
+
+        EXAMPLES::
+
+            sage: from sage.misc.gperftools import Profiler
+            sage: Profiler()
+            Profiler logging to .../tmp....perf
+        """
+        return 'Profiler logging to {0}'.format(self.filename())
+
+    def _libprofiler(self):
+        """
+        Return libprofiler.
+
+        OUTPUT: a ctypes shared library handle
+
+        EXAMPLES::
+
+            sage: from sage.misc.gperftools import Profiler
+            sage: Profiler()._libprofiler()    # optional - gperftools
+            <CDLL 'libprofiler...', handle ... at ...>
+        """
+        global libprofiler
+        if libprofiler is not None:
+            return libprofiler
+        import ctypes.util
+        name = ctypes.util.find_library('profiler')
+        if name:
+            libprofiler = ctypes.CDLL(name)
+            return libprofiler
+        else:
+            raise ImportError('failed to open libprofiler, make sure gperftools is installed')
+
+    def start(self):
+        """
+        Start profiling.
+
+        EXAMPLES::
+
+            sage: from sage.misc.gperftools import Profiler, run_100ms
+            sage: prof = Profiler()
+            sage: prof.start()    # optional - gperftools
+            sage: run_100ms()
+            sage: prof.stop()     # optional - gperftools
+            PROFILE: interrupts/evictions/bytes = ...
+        """
+        from signal import SIGPROF, SIG_DFL
+        from cysignals.pysignals import setossignal
+        self._previous_sigprof_handler = setossignal(SIGPROF, SIG_DFL)
+        profiler = self._libprofiler()
+        self._t_start = time.time()
+        rc = profiler.ProfilerStart(str.encode(self.filename()))
+        if rc < 0:
+            raise ValueError('profiler failed to start')
+
+    def stop(self):
+        """
+        Stop the CPU profiler.
+
+        EXAMPLES::
+
+            sage: from sage.misc.gperftools import Profiler, run_100ms
+            sage: prof = Profiler()
+            sage: prof.start()    # optional - gperftools
+            sage: run_100ms()
+            sage: prof.stop()     # optional - gperftools
+            PROFILE: interrupts/evictions/bytes = ...
+        """
+        profiler = self._libprofiler()
+        profiler.ProfilerStop()
+        self._t_stop = time.time()
+        if (self._t_stop - self._t_start) < 0.1:
+            from warnings import warn
+            warn('not enough samples, total runtime was '
+                 'less than 100ms', RuntimeWarning)
+
+    @cached_method
+    def _pprof(self):
+        """
+        Return the name of the ``pprof`` binary.
+
+        OUTPUT:
+
+        String. The name of the gperftools ``pprof`` utility. A
+        :exc:`OSError` is raised if it cannot be found.
+
+        EXAMPLES::
+
+            sage: from sage.misc.gperftools import Profiler
+            sage: prof = Profiler()
+            sage: try:
+            ....:     pp = prof._pprof()
+            ....:     assert isinstance(pp, str)
+            ....: except OSError:
+            ....:     pass    # not installed
+        """
+        potential_names = ['google-pprof', 'pprof']
+        from subprocess import check_output, CalledProcessError, STDOUT
+        for name in potential_names:
+            try:
+                version = check_output([name, '--version'], stderr=STDOUT)
+            except (CalledProcessError, OSError):
+                continue
+            version = bytes_to_str(version)
+            if 'gperftools' not in version:
+                from warnings import warn
+                warn('the "{0}" utility does not appear to be the gperftools profiler'
+                     .format(name), RuntimeWarning)
+                continue
+            return name
+        raise OSError('unable to run pprof, please install gperftools')
+
+    def _executable(self):
+        """
+        Return the name of the Sage Python interpreter.
+
+        OUTPUT: string
+
+        EXAMPLES::
+
+            sage: from sage.misc.gperftools import Profiler
+            sage: prof = Profiler()
+            sage: prof._executable()
+            '.../python...'
+        """
+        return sys.executable
+
+    def _call_pprof(self, *args, **kwds):
+        """
+        Run the pprof binary.
+
+        INPUT:
+
+        - ``args`` -- list of strings; the arguments to ``pprof``
+
+        - ``kwds`` -- keyword arguments passed to ``subprocess.check_call``
+
+        EXAMPLES::
+
+            sage: from sage.misc.gperftools import Profiler
+            sage: prof = Profiler()
+            sage: prof._call_pprof('--help')   # optional - gperftools
+            Usage:
+            pprof [options] <program> <profiles>
+            ...
+        """
+        from subprocess import check_call
+        check_call([self._pprof()] + list(args), **kwds)
+
+    def top(self, cumulative=True):
+        """
+        Print text report.
+
+        OUTPUT: nothing; a textual report is printed to stdout
+
+        EXAMPLES::
+
+            sage: from sage.misc.gperftools import Profiler
+            sage: prof = Profiler()
+            sage: prof.start()    # optional - gperftools
+            sage: # do something
+            sage: prof.stop()     # optional - gperftools
+            PROFILE: interrupts/evictions/bytes = ...
+            sage: prof.top()   # optional - gperftools
+            Using local file ...
+            Using local file ...
+        """
+        args = []
+        if cumulative:
+            args += ['--cum']
+        args += ['--text', self._executable(), self.filename()]
+        self._call_pprof(*args)
+
+    def save(self, filename, cumulative=True, verbose=True):
+        """
+        Save report to disk.
+
+        INPUT:
+
+        - ``filename`` -- string; the filename to save at. Must end
+          with one of ``.dot``, ``.ps``, ``.pdf``, ``.svg``, ``.gif``,
+          or ``.txt`` to specify the output file format.
+
+        - ``cumulative`` -- boolean (default: ``True``); whether to return
+          cumulative timings
+
+        - ``verbose`` -- boolean (default: ``True``); whether to print
+          informational messages
+
+        EXAMPLES::
+
+            sage: from sage.misc.gperftools import Profiler, run_100ms
+            sage: prof = Profiler()
+            sage: prof.start()    # optional - gperftools
+            sage: run_100ms()     # optional - gperftools
+            sage: prof.stop()     # optional - gperftools
+            PROFILE: interrupts/evictions/bytes = ...
+            sage: f = tmp_filename(ext='.txt')      # optional - gperftools
+            sage: prof.save(f, verbose=False)       # optional - gperftools
+        """
+        args = []
+        if cumulative:
+            args += ['--cum']
+        if filename.endswith('.dot'):
+            args += ['--dot']
+        elif filename.endswith('.ps'):
+            args += ['--ps']
+        elif filename.endswith('.pdf'):
+            args += ['--pdf']
+        elif filename.endswith('.svg'):
+            args += ['--svg']
+        elif filename.endswith('.txt'):
+            args += ['--text']
+        elif filename.endswith('.gif'):
+            args += ['--gif']
+        else:
+            raise ValueError('unknown extension')
+        args += [self._executable(), self.filename()]
+        stderr = sys.stdout if verbose else False
+        with open(filename, 'wb') as outfile:
+            self._call_pprof(*args, stdout=outfile, stderr=stderr)
+
+
+def crun(s, evaluator):
+    """
+    Profile single statement.
+
+    - ``s`` -- string; Sage code to profile
+
+    - ``evaluator`` -- callable to evaluate
+
+    EXAMPLES::
+
+        sage: import sage.misc.gperftools as gperf
+        sage: ev = lambda ex:eval(ex, globals(), locals())
+        sage: gperf.crun('gperf.run_100ms()', evaluator=ev)   # optional - gperftools
+        PROFILE: interrupts/evictions/bytes = ...
+        Using local file ...
+        Using local file ...
+    """
+    prof = Profiler()
+    from sage.repl.preparse import preparse
+    py_s = preparse(s)
+    prof.start()
+    try:
+        evaluator(py_s)
+    finally:
+        prof.stop()
+    prof.top()
+
+
+def run_100ms():
+    """
+    Used for doctesting.
+
+    A function that performs some computation for more than (but not
+    that much more than) 100ms.
+
+    EXAMPLES::
+
+        sage: from sage.misc.gperftools import run_100ms
+        sage: run_100ms()
+    """
+    t0 = time.time()   # start
+    t1 = t0 + 0.1      # end
+    from sage.symbolic.ring import SR
+    while time.time() < t1:
+        sum(1 / (1 + SR(n) ** 2) for n in range(100))

sage/misc/inline_fortran.py

@@ -0,0 +1,212 @@
+# sage_setup: distribution = sagemath-repl
+"""
+Fortran compiler
+"""
+
+import importlib
+import os
+import shutil
+import subprocess
+import sys
+
+from sage.misc.temporary_file import tmp_dir
+
+
+def _import_module_from_path(name, path=None):
+    """
+    Import the module named ``name`` by searching the given path entries (or
+    `sys.path` by default).
+
+    Returns a fully executed module object without inserting that module into
+    `sys.modules`.
+
+    EXAMPLES::
+
+        sage: from sage.misc.inline_fortran import _import_module_from_path
+        sage: modname = '___test__import_module_from_path'
+        sage: tmpdir = tmp_dir()
+        sage: filename = os.path.join(tmpdir, modname + '.py')
+        sage: with open(filename, 'w') as fobj:
+        ....:     _ = fobj.write('foo = "bar"')
+        sage: mod = _import_module_from_path(modname)
+        Traceback (most recent call last):
+        ...
+        ImportError: No module named ___test__import_module_from_path
+        sage: mod = _import_module_from_path('DoEsNoTeXiSt', path=[tmpdir])
+        Traceback (most recent call last):
+        ...
+        ImportError: No module named DoEsNoTeXiSt
+        sage: mod = _import_module_from_path(modname, path=[tmpdir])
+        sage: mod.foo
+        'bar'
+    """
+
+    if path is None:
+        path = sys.path
+
+    return _import_module_from_path_impl(name, path)
+
+
+def _import_module_from_path_impl(name, path):
+    """Implement ``_import_module_from_path`` for Python 3.4+."""
+
+    # This is remarkably tricky to do right, considering that the new
+    # importlib is supposed to make direct interaction with the import
+    # system easier.  I blame the ModuleSpec stuff...
+    finder = importlib.machinery.PathFinder()
+    spec = finder.find_spec(name, path=path)
+    if spec is None:
+        raise ImportError('No module named {}'.format(name))
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+class InlineFortran:
+    def __init__(self, globals=None):
+        # globals=None means: use user globals from REPL
+        self.globs = globals
+        self.library_paths = []
+        self.libraries = []
+        self.verbose = False
+
+    def __repr__(self):
+        return "Interface to Fortran compiler"
+
+    def __call__(self, *args, **kwds):
+        return self.eval(*args, **kwds)
+
+    def eval(self, x, globals=None, locals=None):
+        """
+        Compile fortran code ``x`` and adds the functions in it to ``globals``.
+
+        INPUT:
+
+        - ``x`` -- fortran code
+
+        - ``globals`` -- dictionary to which to add the functions from the
+          fortran module
+
+        - ``locals`` -- ignored
+
+        EXAMPLES::
+
+            sage: # needs numpy
+            sage: code = '''
+            ....: C FILE: FIB1.F
+            ....:       SUBROUTINE FIB(A,N)
+            ....: C
+            ....: C     CALCULATE FIRST N FIBONACCI NUMBERS
+            ....: C
+            ....:       INTEGER N
+            ....:       REAL*8 A(N)
+            ....:       DO I=1,N
+            ....:          IF (I.EQ.1) THEN
+            ....:             A(I) = 0.0D0
+            ....:          ELSEIF (I.EQ.2) THEN
+            ....:             A(I) = 1.0D0
+            ....:          ELSE
+            ....:             A(I) = A(I-1) + A(I-2)
+            ....:          ENDIF
+            ....:       ENDDO
+            ....:       END
+            ....: C END FILE FIB1.F
+            ....: '''
+            sage: fortran(code, globals())
+            sage: import numpy
+            sage: a = numpy.array(range(10), dtype=float)
+            sage: fib(a, 10)
+            sage: a
+            array([  0.,   1.,   1.,   2.,   3.,   5.,   8.,  13.,  21.,  34.])
+
+        TESTS::
+
+            sage: os.chdir(DOT_SAGE)
+            sage: fortran.eval("SYNTAX ERROR !@#$")
+            Traceback (most recent call last):
+            ...
+            RuntimeError: failed to compile Fortran code:...
+            sage: os.getcwd() == os.path.realpath(DOT_SAGE)
+            True
+        """
+        if globals is None:
+            globals = self.globs
+            if globals is None:
+                from sage.repl.user_globals import get_globals
+                globals = get_globals()
+
+        # Create everything in a temporary directory
+        mytmpdir = tmp_dir()
+
+        try:
+            old_cwd = os.getcwd()
+            os.chdir(mytmpdir)
+
+            name = "fortran_module"  # Python module name
+            # if the first line has !f90 as a comment, gfortran will
+            # treat it as Fortran 90 code
+            if x.startswith('!f90'):
+                fortran_file = name + '.f90'
+            else:
+                fortran_file = name + '.f'
+
+            s_lib_path = ['-L' + p for p in self.library_paths]
+            s_lib = ['-l' + l for l in self.libraries]
+
+            with open(fortran_file, 'w') as fobj:
+                fobj.write(x)
+
+            # This is basically the same as what f2py.compile() does, but we
+            # do it manually here in order to customize running the subprocess
+            # a bit more (in particular to capture stderr)
+            cmd = [sys.executable, '-c', 'import numpy.f2py; numpy.f2py.main()']
+
+            # What follows are the arguments to f2py itself (appended later
+            # just for logical separation)
+            cmd += ['-c', '-m', name, fortran_file, '--quiet',
+                    '--f77exec=sage-inline-fortran',
+                    '--f90exec=sage-inline-fortran'] + s_lib_path + s_lib
+
+            try:
+                out = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+            except subprocess.CalledProcessError as exc:
+                raise RuntimeError(
+                    "failed to compile Fortran code:\n{}".format(exc.output))
+
+            # Note that f2py() doesn't raise an exception if it fails.
+            # In that case, the import below will fail.
+            try:
+                mod = _import_module_from_path(name, [mytmpdir])
+            except ImportError as exc:
+                # Failed to import the module; include any output from building
+                # the module (even though it was ostensibly successful) in case
+                # it might help
+                msg = "failed to load compiled Fortran code: {}".format(exc)
+                if out:
+                    msg += '\n' + out
+                raise RuntimeError(msg)
+
+            if self.verbose:
+                print(out)
+        finally:
+            os.chdir(old_cwd)
+
+            try:
+                shutil.rmtree(mytmpdir)
+            except OSError:
+                # This can fail for example over NFS
+                pass
+
+        for k, x in mod.__dict__.items():
+            if k[0] != '_':
+                globals[k] = x
+
+    def add_library(self, s):
+        self.libraries.append(s)
+
+    def add_library_path(self, s):
+        self.library_paths.append(s)
+
+
+# An instance
+fortran = InlineFortran()

sage/misc/messaging.py

@@ -0,0 +1,86 @@
+# sage_setup: distribution = sagemath-repl
+"""
+Message delivery
+
+Various interfaces to messaging services. Currently:
+
+- ``pushover`` -- a platform for sending and receiving push notifications
+
+is supported.
+
+AUTHORS:
+
+- Martin Albrecht (2012) - initial implementation
+"""
+
+import http.client as httplib
+from urllib.parse import urlencode
+from ssl import create_default_context as default_context
+
+pushover_defaults = {"token": "Eql67F14ohOZJ0AtEBJJU7FiLAk8wK"}
+
+
+def pushover(message, **kwds):
+    """
+    Send a push notification with ``message`` to ``user`` using https://pushover.net/.
+
+    Pushover is a platform for sending and receiving push notifications. On the server side, it
+    provides an HTTP API for queueing messages to deliver to devices. On the device side, iOS and
+    Android clients receive those push notifications, show them to the user, and store them for
+    offline viewing.
+
+    An account on https://pushover.net is required and the Pushover app must be installed on your
+    phone for this function to be able to deliver messages to you.
+
+    INPUT:
+
+      - ``message`` -- your message
+
+      - ``user`` -- the user key (not e-mail address) of your user (or you), viewable when logged
+        into the Pushover dashboard. (default: ``None``)
+
+      - ``device`` -- your user's device identifier to send the message directly to that device,
+        rather than all of the user's devices (default: ``None``)
+
+      - ``title`` -- your message's title, otherwise uses your app's name (default: ``None``)
+
+      - ``url`` -- a supplementary URL to show with your message (default: ``None``)
+
+      - ``url_title`` -- a title for your supplementary URL (default: ``None``)
+
+      - ``priority`` -- set to 1 to display as high-priority and bypass quiet hours, or -1 to always
+        send as a quiet notification (default: ``0``)
+
+      - ``timestamp`` -- set to a unix timestamp to have your message show with a particular time,
+        rather than now (default: ``None``)
+
+      - ``sound`` -- set to the name of one of the sounds supported by device clients to override the
+        user's default sound choice (default: ``None``)
+
+      - ``token`` -- your application's API token (default: Sage's default App token)
+
+    EXAMPLES::
+
+        sage: import sage.misc.messaging
+        sage: sage.misc.messaging.pushover("Hi, how are you?", user="XXX") # not tested
+
+    To set default values populate ``pushover_defaults``::
+
+        sage: sage.misc.messaging.pushover_defaults["user"] = "USER_TOKEN"
+        sage: sage.misc.messaging.pushover("Hi, how are you?") # not tested
+
+    .. NOTE::
+
+        You may want to populate ``sage.misc.messaging.pushover_defaults`` with default values such
+        as the default user in ``$HOME/.sage/init.sage``.
+    """
+    request = {"message": message}
+    request.update(pushover_defaults)
+    request.update(kwds)
+
+    conn = httplib.HTTPSConnection("api.pushover.net:443",
+                                   context=default_context())
+    conn.request("POST", "/1/messages.json",
+                 urlencode(request),
+                 {"Content-type": "application/x-www-form-urlencoded"})
+    return conn.getresponse().status == 200

sage/misc/pager.py

@@ -0,0 +1,21 @@
+# sage_setup: distribution = sagemath-repl
+"""
+Pager for showing strings
+
+Currently we just use the IPython pager.
+If we want to use something else, we can just change this function.
+
+Any code in sage that uses a pager should use this pager.
+"""
+# ---------------------------------------------------------------------------
+#       Copyright (C) 2006 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#                  https://www.gnu.org/licenses/
+# ---------------------------------------------------------------------------
+
+
+def pager():
+    import IPython.core.page
+    return IPython.core.page.page