passagemath-repl 10.4.62__py3-none-any.whl

sage/misc/profiler.py

@@ -0,0 +1,179 @@
+# sage_setup: distribution = sagemath-repl
+r"""
+Simple profiling tool
+
+AUTHORS:
+
+- David Harvey (August 2006)
+- Martin Albrecht
+"""
+
+# *****************************************************************************
+#       Copyright (C) 2006 William Stein <wstein@gmail.com>
+#                     2006 David Harvey <dmharvey@math.harvard.edu>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#                  http://www.gnu.org/licenses/
+# *****************************************************************************
+
+from sage.misc.timing import cputime
+import inspect
+import sys
+
+
+class Profiler:
+    r"""
+    Keeps track of CPU time used between a series of user-defined checkpoints.
+
+    It's probably not a good idea to use this class in an inner loop :-)
+
+    EXAMPLES::
+
+        from sage.misc.profiler import Profiler
+        sage: def f():                        # not tested
+        ....:     p = Profiler()
+
+    Calling ``p(message)`` creates a checkpoint::
+
+        sage: p("try factoring 15")           # not tested
+
+    Do something time-consuming::
+
+        sage: x = factor(15)                  # not tested
+
+    You can create a checkpoints without a string; ``Profiler``
+    will use the source code instead::
+
+        sage: # not tested
+        sage: p()
+        sage: y = factor(25)
+        sage: p("last step")
+        sage: z = factor(35)
+        sage: p()
+
+    This will give a nice list of timings between checkpoints::
+
+        sage: print(p)                        # not tested
+
+    Let's try it out::
+
+        sage: f()                             # not tested
+            3.020s -- try factoring 15
+           15.240s -- line 17: y = factor(25)
+         5000.190s -- last step
+
+    .. SEEALSO:: :func:`runsnake`
+
+    .. TODO::
+
+        - Add Pyrex source code inspection (I assume it doesn't
+          currently do this)
+        - Add ability to sort output by time
+        - Add option to constructor to print timing immediately when
+          checkpoint is reached
+        - Migrate to Pyrex?
+        - Add ability to return timings in a more machine-friendly
+          format
+
+    AUTHOR:
+
+    - David Harvey (August 2006)
+    """
+
+    def __init__(self, systems=[], verbose=False):
+        """
+        INPUT:
+
+        - ``systems`` -- list of interfaces to other system which implements a
+          cputime method. The cputimes of all provided systems will be added
+          to the cputime of Sage itself.
+        """
+        systems = [e.cputime for e in systems]
+        self._cputime_functions = [cputime] + list(systems)
+        self._verbose = bool(verbose)
+        self.clear()
+
+    def clear(self):
+        # _checkpoints is list of pairs (details, time), where time is a float
+        # and details is a triple (line_number, context, message)
+        self._checkpoints = []
+        self._active_details = None   # details from the last __call__() call
+        self._last_cputime = [None]*len(self._cputime_functions)
+
+    def __call__(self, message=None):
+        """ Adds a checkpoint. """
+        entry_times = [fn() for fn in self._cputime_functions]
+
+        frame = inspect.currentframe().f_back
+        try:
+            frame_info = inspect.getframeinfo(frame, 9)
+            line_number = frame_info[1]
+            context = frame_info[3]
+        finally:
+            # This is here to prevent reference cycles
+            # (according to the warning in the python documentation:
+            # http://docs.python.org/lib/inspect-stack.html):
+            del frame_info
+            del frame
+
+        if self._active_details is not None:
+            _time = sum([entry_times[i]-self._last_cputime[i] for i in range(len(entry_times))])
+            self._checkpoints.append((self._active_details, _time))
+
+        self._active_details = (line_number, context, message)
+
+        self._last_cputime = [fn() for fn in self._cputime_functions]
+        if self._verbose:
+            print(self.print_last())
+            sys.stdout.flush()
+
+    def __repr__(self):
+        """ Returns a nicely formatted table of stored checkpoints and timings. """
+        if not self._checkpoints:
+            return "no checkpoints defined"
+
+        output = []
+        for ((line_number, context, message), time_used) in self._checkpoints:
+            if message is None:
+                # If the user hasn't given a message, we look for some
+                # source code to print instead
+                found = "(unknown)"
+                for line in context[5:]:
+                    line = line.strip()
+                    if line != "":
+                        found = line
+                        break
+
+                if len(found) > 60:
+                    found = found[:60] + "..."   # in case the source line is really long
+                message = "line %d: %s" % (line_number, found)
+
+            output.append("%9.3fs -- %s" % (time_used, message))
+
+        return "\n".join(output)
+
+    def print_last(self):
+        """
+        Print the last profiler step.
+        """
+        if not self._checkpoints:
+            return ""
+
+        ((line_number, context, message), time_used) = self._checkpoints[-1]
+        if message is None:
+            # If the user hasn't given a message, we look for some
+            # source code to print instead
+            found = "(unknown)"
+            for line in context[5:]:
+                line = line.strip()
+                if line != "":
+                    found = line
+                    break
+
+            if len(found) > 60:
+                found = found[:60] + "..."   # in case the source line is really long
+            message = "line %d: %s" % (line_number, found)
+
+        return "%9.3fs -- %s" % (time_used, message)
+
+# end of file

sage/misc/python.py

@@ -0,0 +1,70 @@
+# sage_setup: distribution = sagemath-repl
+"Evaluating Python code without any preparsing"
+
+
+class Python:
+    """
+    Allow for evaluating a chunk of code without any preparsing.
+    """
+
+    def eval(self, x, globals, locals=None):
+        r"""
+        Evaluate x with given globals; locals is completely ignored.
+
+        This is specifically meant for evaluating code blocks with
+        ``%python`` in the notebook.
+
+        INPUT:
+
+        - ``x`` -- string
+        - ``globals`` -- dictionary
+        - ``locals`` -- completely IGNORED
+
+        EXAMPLES::
+
+            sage: from sage.misc.python import Python
+            sage: python = Python()
+            sage: python.eval('2+2', globals())
+            4
+            ''
+
+        Any variables that are set during evaluation of the block
+        will propagate to the globals dictionary. ::
+
+            sage: python.eval('a=5\nb=7\na+b', globals())
+            12
+            ''
+            sage: b
+            7
+
+        The ``locals`` variable is ignored -- it is there only for
+        completeness.  It is ignored since otherwise the following
+        will not work::
+
+            sage: python.eval("def foo():\n   return 'foo'\nprint(foo())\ndef mumble():\n    print('mumble {}'.format(foo()))\nmumble()", globals())
+            foo
+            mumble foo
+            ''
+            sage: mumble
+            <function mumble at ...>
+        """
+        x = x.strip()
+        y = x.split('\n')
+        if not y:
+            return ''
+        s = '\n'.join(y[:-1]) + '\n'
+        t = y[-1]
+        try:
+            z = compile(t + '\n', '', 'single')
+        except SyntaxError:
+            s += '\n' + t
+            z = None
+
+        eval(compile(s, '', 'exec'), globals, globals)
+
+        if z is not None:
+            eval(z, globals)
+        return ''
+
+
+python = Python()

sage/misc/remote_file.py

@@ -0,0 +1,53 @@
+# sage_setup: distribution = sagemath-repl
+"get_remote_file"
+import os
+from pathlib import Path
+from urllib.request import Request, urlopen
+from ssl import create_default_context as default_context
+
+
+def get_remote_file(filename, verbose=True) -> Path:
+    """
+    INPUT:
+
+    - ``filename`` -- the URL of a file on the web, e.g.,
+      ``'http://modular.math.washington.edu/myfile.txt'``
+
+    - ``verbose`` -- whether to display download status
+
+    OUTPUT:
+
+    This creates a file in the temp directory and returns the absolute path
+    to that file as a :class:`Path` object.
+
+    EXAMPLES::
+
+        sage: url = 'https://www.sagemath.org/files/loadtest.py'
+        sage: g = get_remote_file(url, verbose=False)      # optional - internet
+        sage: with open(g) as f: print(f.read())           # optional - internet
+        print("hi from the net")
+        <BLANKLINE>
+        print(2 + 3)
+    """
+    if verbose:
+        print("Attempting to load remote file: " + filename)
+
+    from sage.misc.temporary_file import tmp_filename
+    ext = os.path.splitext(filename)[1]
+    temp_name = Path(tmp_filename(ext=ext))
+    # IMPORTANT -- urllib takes a long time to load,
+    # so do not import it in the module scope.
+
+    req = Request(filename, headers={"User-Agent": "sage-doctest"})
+
+    if verbose:
+        print("Loading started")
+
+    content = urlopen(req, timeout=1, context=default_context())
+    with temp_name.open('wb') as f:
+        f.write(content.read())
+
+    if verbose:
+        print("Loading ended")
+
+    return temp_name

sage/misc/sage_eval.py

@@ -0,0 +1,246 @@
+# sage_setup: distribution = sagemath-repl
+r"""
+Evaluating a String in Sage
+"""
+# ****************************************************************************
+#       Copyright (C) 2006 William Stein <wstein@gmail.com>
+#
+#  Distributed under the terms of the GNU General Public License (GPL)
+#
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+from copy import copy
+import sage.repl.preparse as preparser
+
+
+def sage_eval(source, locals=None, cmds='', preparse=True):
+    r"""
+    Obtain a Sage object from the input string by evaluating it using
+    Sage. This means calling eval after preparsing and with globals
+    equal to everything included in the scope of ``from sage.all
+    import *``.).
+
+    INPUT:
+
+    - ``source`` -- string or object with a ``_sage_``
+      method
+
+    - ``locals`` -- evaluate in namespace of :mod:`sage.all` plus
+      the locals dictionary
+
+    - ``cmds`` -- string; sequence of commands to be run
+      before source is evaluated
+
+    - ``preparse`` -- boolean (default: ``True``); if ``True``, preparse the
+      string expression
+
+    EXAMPLES: This example illustrates that preparsing is applied::
+
+        sage: eval('2^3')
+        1
+        sage: sage_eval('2^3')
+        8
+
+    However, preparsing can be turned off::
+
+        sage: sage_eval('2^3', preparse=False)
+        1
+
+    Note that you can explicitly define variables and pass them as the
+    second option::
+
+        sage: x = PolynomialRing(RationalField(),"x").gen()
+        sage: sage_eval('x^2+1', locals={'x':x})
+        x^2 + 1
+
+    This example illustrates that evaluation occurs in the context of
+    ``from sage.all import *``. Even though ``bernoulli`` has
+    been redefined in the local scope, when calling
+    :func:`sage_eval` the default value meaning of :func:`bernoulli`
+    is used. Likewise for ``QQ`` below::
+
+        sage: bernoulli = lambda x : x^2
+        sage: bernoulli(6)
+        36
+        sage: eval('bernoulli(6)')
+        36
+        sage: sage_eval('bernoulli(6)')                                                 # needs sage.libs.flint
+        1/42
+
+    ::
+
+        sage: QQ = lambda x : x^2
+        sage: QQ(2)
+        4
+        sage: sage_eval('QQ(2)')
+        2
+        sage: parent(sage_eval('QQ(2)'))
+        Rational Field
+
+    This example illustrates setting a variable for use in evaluation::
+
+        sage: x = 5
+        sage: eval('4//3 + x', {'x': 25})
+        26
+        sage: sage_eval('4/3 + x',  locals={'x': 25})
+        79/3
+
+    You can also specify a sequence of commands to be run before the
+    expression is evaluated::
+
+        sage: sage_eval('p', cmds='K.<x> = QQ[]\np = x^2 + 1')
+        x^2 + 1
+
+    If you give commands to execute and a dictionary of variables, then
+    the dictionary will be modified by assignments in the commands::
+
+        sage: vars = {}
+        sage: sage_eval('None', cmds='y = 3', locals=vars)
+        sage: vars['y'], parent(vars['y'])
+        (3, Integer Ring)
+
+    You can also specify the object to evaluate as a tuple. A 2-tuple
+    is assumed to be a pair of a command sequence and an expression; a
+    3-tuple is assumed to be a triple of a command sequence, an
+    expression, and a dictionary holding local variables. (In this
+    case, the given dictionary will not be modified by assignments in
+    the commands.)
+
+    ::
+
+        sage: sage_eval(('f(x) = x^2', 'f(3)'))                                         # needs sage.symbolic
+        9
+        sage: vars = {'rt2': sqrt(2.0)}
+        sage: sage_eval(('rt2 += 1', 'rt2', vars))
+        2.41421356237309
+        sage: vars['rt2']
+        1.41421356237310
+
+    This example illustrates how :mod:`sage_eval` can be
+    useful when evaluating the output of other computer algebra
+    systems::
+
+        sage: # needs sage.libs.gap
+        sage: R.<x> = PolynomialRing(RationalField())
+        sage: gap.eval('R:=PolynomialRing(Rationals,["x"]);')
+        'Rationals[x]'
+        sage: ff = gap.eval('x:=IndeterminatesOfPolynomialRing(R);; f:=x^2+1;'); ff
+        'x^2+1'
+        sage: sage_eval(ff, locals={'x':x})
+        x^2 + 1
+        sage: eval(ff)
+        Traceback (most recent call last):
+        ...
+        RuntimeError: Use ** for exponentiation, not '^', which means xor
+        in Python, and has the wrong precedence.
+
+    Here you can see that :func:`eval` simply will not work but
+    :func:`sage_eval` will.
+
+    TESTS:
+
+    We get a nice minimal error message for syntax errors, that still
+    points to the location of the error (in the input string)::
+
+        sage: sage_eval('RR(22/7]')
+        Traceback (most recent call last):
+        ...
+         File "<string>", line 1
+            RR(Integer(22)/Integer(7)]
+                                     ^
+        SyntaxError: ...
+
+    ::
+
+        sage: sage_eval('None', cmds='$x = $y[3] # Does Perl syntax work?')
+        Traceback (most recent call last):
+        ...
+         File "<string>", line 1
+            $x = $y[Integer(3)] # Does Perl syntax work?
+            ^
+        SyntaxError: invalid ...
+    """
+    if isinstance(source, (list, tuple)):
+        cmds = source[0]
+        if len(source) > 2:
+            locals = copy(source[2])
+        source = source[1]
+
+    if not isinstance(source, str):
+        raise TypeError("source must be a string.")
+
+    if locals is None:
+        locals = {}
+
+    try:
+        import sage.all as toplevel
+    except ImportError:
+        try:
+            import sage.all__sagemath_polyhedra as toplevel
+        except ImportError:
+            try:
+                import sage.all__sagemath_categories as toplevel
+            except ImportError:
+                import sage.all__sagemath_objects as toplevel
+    if cmds:
+        cmd_seq = cmds + '\n_sage_eval_returnval_ = ' + source
+        if preparse:
+            cmd_seq = preparser.preparse_file(cmd_seq)
+    else:
+        if preparse:
+            source = preparser.preparse(source)
+
+    if cmds:
+        exec(cmd_seq, toplevel.__dict__, locals)
+        return locals['_sage_eval_returnval_']
+    else:
+        return eval(source, toplevel.__dict__, locals)
+
+
+def sageobj(x, vars=None):
+    """
+    Return a native Sage object associated to ``x``, if possible and
+    implemented.
+
+    If the object has a ``_sage_`` method it is called and the value is
+    returned. Otherwise, :func:`str` is called on the object, and all preparsing
+    is applied and the resulting expression is evaluated in the context
+    of ``from sage.all import *``. To evaluate the
+    expression with certain variables set, use the ``vars`` argument, which
+    should be a dictionary.
+
+    EXAMPLES::
+
+        sage: type(sageobj(gp('34/56')))                                                # needs sage.libs.pari
+        <class 'sage.rings.rational.Rational'>
+
+        sage: n = 5/2
+        sage: sageobj(n) is n
+        True
+        sage: k = sageobj('Z(8^3/1)', {'Z':ZZ}); k
+        512
+        sage: type(k)
+        <class 'sage.rings.integer.Integer'>
+
+    This illustrates interfaces::
+
+        sage: # needs sage.libs.pari
+        sage: f = gp('2/3')
+        sage: type(f)
+        <class 'sage.interfaces.gp.GpElement'>
+        sage: f._sage_()
+        2/3
+        sage: type(f._sage_())
+        <class 'sage.rings.rational.Rational'>
+
+        sage: # needs sage.libs.gap
+        sage: a = gap(939393/2433)
+        sage: a._sage_()
+        313131/811
+        sage: type(a._sage_())
+        <class 'sage.rings.rational.Rational'>
+    """
+    try:
+        return x._sage_()
+    except (TypeError, NotImplementedError, AttributeError):
+        return sage_eval(str(x), vars)