passagemath-repl 10.4.62__py3-none-any.whl

sage/misc/sh.py

@@ -0,0 +1,38 @@
+# sage_setup: distribution = sagemath-repl
+"Evaluating shell scripts"
+
+import os
+
+
+class Sh:
+    r"""
+    Evaluates a shell script and returns the output.
+
+    To use this from the notebook type ``sh`` at the beginning of
+    the input cell.  The working directory is then the (usually
+    temporary) directory where the Sage worksheet process is
+    executing.
+    """
+    def eval(self, code, globals=None, locals=None):
+        r"""
+        This is difficult to test because the output goes to the
+        screen rather than being captured by the doctest program, so
+        the following really only tests that the command doesn't bomb,
+        not that it gives the right output::
+
+            sage: sh.eval('''echo "Hello there"\nif [ $? -eq 0 ]; then\necho "good"\nfi''') # random output
+        """
+        # Print out the current absolute path, which is where the code
+        # will be evaluated.    Evidently, users find this comforting,
+        # though I personally find it to be a bit much (William Stein).
+        print(os.path.abspath('.'))
+        # Evaluate the input code block.  Fortunately, os.system works
+        # fine with multiline input (in contrast to subprocess.Popen).
+        os.system(str(code))
+        # Return '' so nothing extra (for example an unsightly None)
+        # gets printed when doing %sh in the notebook.
+        return ''
+
+
+# Create the sh object, so that %sh mode works in the notebook.
+sh = Sh()

sage/misc/trace.py

@@ -0,0 +1,90 @@
+# sage_setup: distribution = sagemath-repl
+"""
+Interactively tracing execution of a command
+"""
+
+
+def trace(code, preparse=True):
+    r"""
+    Evaluate Sage code using the interactive tracer and return the
+    result. The string ``code`` must be a valid expression
+    enclosed in quotes (no assignments - the result of the expression
+    is returned). In the Sage notebook this just raises a
+    NotImplementedException.
+
+    INPUT:
+
+    - ``code`` -- string
+
+    - ``preparse`` -- boolean (default: ``True``); if ``True``, run
+      expression through the Sage preparser
+
+    REMARKS: This function is extremely powerful! For example, if you
+    want to step through each line of execution of, e.g.,
+    ``factor(100)``, type
+
+    ::
+
+        sage: from sage.misc.trace import trace
+        sage: trace("factor(100)")             # not tested
+
+    then at the (Pdb) prompt type ``s`` (or ``step``), then press :kbd:`Return`
+    over and over to step through every line of Python that is called
+    in the course of the above computation. Type ``?`` at any time for
+    help on how to use the debugger (e.g., ``l`` lists 11 lines around
+    the current line; ``bt`` gives a back trace, etc.).
+
+    Setting a break point: If you have some code in a file and would
+    like to drop into the debugger at a given point, put the following
+    code at that point in the file:
+
+    ``import pdb; pdb.set_trace()``
+
+    For an article on how to use the Python debugger, see
+    http://www.onlamp.com/pub/a/python/2005/09/01/debugger.html
+
+    TESTS:
+
+    For tests we disable garbage collection, see :issue:`21258` ::
+
+        sage: import gc
+        sage: gc.disable()
+
+    The only real way to test this is via pexpect spawning a
+    sage subprocess that uses IPython::
+
+        sage: # needs pexpect sage.all
+        sage: import pexpect
+        sage: s = pexpect.spawn('sage')
+        sage: _ = s.sendline("from sage.misc.trace import trace; trace('print(factor(10))'); print(3+97)")
+        sage: _ = s.expect('ipdb>', timeout=90)
+        sage: _ = s.sendline("s"); _ = s.sendline("c")
+        sage: _ = s.expect('100', timeout=90)
+
+    Seeing the ipdb prompt and the 2 \* 5 in the output below is a
+    strong indication that the trace command worked correctly::
+
+        sage: print(s.before[s.before.find(b'--'):].decode())                           # needs pexpect sage.all
+        --...
+        ...ipdb> c
+        ...2 * 5...
+
+    Re-enable garbage collection::
+
+        sage: gc.enable()
+    """
+    from IPython.core.debugger import Pdb
+    pdb = Pdb()
+
+    try:
+        ipython = get_ipython()
+    except NameError:
+        raise NotImplementedError("the trace command can only be run from the Sage command-line")
+
+    from sage.repl.preparse import preparse
+    code = preparse(code)
+    return pdb.run(code, ipython.user_ns)
+
+    # this could also be useful; it drops
+    # us into a debugger in an except block:
+    #     import pdb; pdb.post_mortem(sys.exc_info()[2])

sage/repl/__init__.py

@@ -0,0 +1,16 @@
+# sage_setup: distribution = sagemath-repl
+# IPython calls this when "%load_ext sage.repl" is used.
+# The Sage application loads it when starting up.
+def load_ipython_extension(*args):
+    import sage.repl.ipython_extension
+    sage.repl.ipython_extension.load_ipython_extension(*args)
+
+
+# The above used to be in sage.__init__, allowing users to use "%load_ext sage".
+# But we are clearing out the __init__.py file as a preparation for
+# making sage a native namespace package.
+#
+# So we make "%load_ext sage" work by monkey-patching the function
+# into the sage package upon importing sage.repl.
+import sage
+sage.load_ipython_extension = load_ipython_extension

sage/repl/all.py

@@ -0,0 +1,15 @@
+# sage_setup: distribution = sagemath-repl
+from sage.misc.lazy_import import lazy_import
+
+from sage.repl.preparse import preparse, implicit_multiplication
+
+lazy_import('sage.repl.interpreter', 'preparser')
+
+lazy_import('sage.repl.attach', [
+    'attach', 'detach', 'attached_files', 'load_attach_path',
+    'reset_load_attach_path', 'load_attach_mode'])
+
+from sage.repl.rich_output.display_manager import get_display_manager
+
+from sage.repl.rich_output.pretty_print import pretty_print, show
+del lazy_import