passagemath-repl 10.4.62__py3-none-any.whl

passagemath_repl-10.4.62.data/scripts/sage-inline-fortran

@@ -0,0 +1,12 @@
+#!/bin/sh
+
+# Compile Fortran code within Sage,
+# see src/sage/misc/inline_fortran.py
+
+[ -n "$FC" ] || FC=gfortran
+
+if [ "$UNAME" = "Darwin" ]; then
+    exec $FC -bundle -undefined dynamic_lookup "$@"
+else
+    exec $FC -shared "$@"
+fi

passagemath_repl-10.4.62.data/scripts/sage-ipynb2rst

@@ -0,0 +1,50 @@
+#!/usr/bin/env bash
+
+if [ -z $SAGE_EXTCODE ]; then
+    SAGE_EXTCODE=`${0/-ipynb2rst} -c "from sage.env import SAGE_EXTCODE; print(SAGE_EXTCODE)"`
+fi
+
+fail () {
+    echo "ERROR: ${1}" 1>&2
+    exit 1
+}
+
+help () {
+    cat << EOF
+Usage:
+
+    sage -ipynb2rst <source> [<destination>]
+
+Generates reStructuredText source (.rst) from IPython worksheet (.ipynb).
+
+If the destination is not specified, the reStructuredText source is written in
+the standard output.
+
+Examples:
+
+    sage -ipynb2rst file.ipynb file.rst
+
+    sage -ipynb2rst file.ipynb
+
+Options:
+  -h, --help            show this help message and exit
+EOF
+}
+
+if [ "${1}" = '-h' ] || [ "${1}" = '--help' ] ; then help ; exit 0 ; fi
+
+case  "${#}" in
+    (1)
+        jupyter nbconvert --to rst --RSTExporter.template_path=[\'$SAGE_EXTCODE/nbconvert/\'] --RSTExporter.template_file='rst_sage.tpl' --NbConvertApp.output_files_dir='.' --output-dir='.' "${1}" || ( echo -e '\n' ; help )
+        $SAGE_EXTCODE/nbconvert/postprocess.py "${1/.ipynb/.rst}"
+        ;;
+    (2)
+        jupyter nbconvert --output="${2}" --to rst --RSTExporter.template_path=[\'$SAGE_EXTCODE/nbconvert/\'] --RSTExporter.template_file='rst_sage.tpl' --NbConvertApp.output_files_dir='.' "${1}" || ( echo -e '\n' ; help )
+        $SAGE_EXTCODE/nbconvert/postprocess.py "${2}"
+        ;;
+    (*)
+        help ;;
+esac
+
+exit 0
+

passagemath_repl-10.4.62.data/scripts/sage-ipython

@@ -0,0 +1,16 @@
+#!python
+# -*- coding: utf-8 -*-
+"""
+Sage IPython startup script.
+"""
+
+# Display startup banner. Do this before anything else to give the user
+# early feedback that Sage is starting.
+from sage.misc.banner import banner
+banner()
+
+from sage.repl.interpreter import SageTerminalApp
+
+app = SageTerminalApp.instance()
+app.initialize()
+app.start()

passagemath_repl-10.4.62.data/scripts/sage-massif

@@ -0,0 +1,25 @@
+#!/bin/sh
+
+# We reuse the gdb pythonstartup script.
+PYTHONSTARTUP=`dirname $0`/sage-ipython
+export PYTHONSTARTUP
+echo $PYTHONSTARTUP
+if [ ! -d "$DOT_SAGE/valgrind" ]; then
+    mkdir "$DOT_SAGE/valgrind"
+fi
+
+LOG="$DOT_SAGE"/valgrind/sage-massif.%p
+echo "Log file is $LOG"
+
+MASSIF_FLAGS="--log-file=$LOG --depth=6 "; export MASSIF_FLAGS
+if [ "$SAGE_MASSIF_FLAGS" ]; then
+    echo "Overwriting massif flags with:"
+    echo $SAGE_MASSIF_FLAGS
+    MASSIF_FLAGS=$SAGE_MASSIF_FLAGS; export MASSIF_FLAGS
+else
+    echo "Using default flags:"
+    echo $MASSIF_FLAGS
+fi
+
+valgrind --tool=massif $MASSIF_FLAGS sage-python -i
+

passagemath_repl-10.4.62.data/scripts/sage-notebook

@@ -0,0 +1,267 @@
+#!python
+# -*- coding: utf-8; mode: python -*-
+
+import os
+import sys
+import ast
+import argparse
+import logging
+import textwrap
+from contextlib import contextmanager
+
+logging.basicConfig()
+logger = logging.getLogger()
+
+from sage.misc.banner import banner
+
+
+_system_jupyter_url = "https://doc.sagemath.org/html/en/installation/launching.html#setting-up-sagemath-as-a-jupyter-kernel-in-an-existing-jupyter-notebook-or-jupyterlab-installation"
+
+
+class NotebookJupyter():
+
+    def print_banner(self):
+        print('Please wait while the Sage Jupyter Notebook server starts...')
+
+    @classmethod
+    def print_help(cls):
+        cls(['help'])
+
+    def __init__(self, argv):
+        self.print_banner()
+        try:
+            try:
+                # notebook 6
+                from notebook.notebookapp import main
+            except ImportError:
+                # notebook 7
+                from notebook.app import main
+        except ImportError:
+            import traceback
+            traceback.print_exc()
+            print("The Jupyter notebook is not installed (at least not in this Sage installation).")
+            print("You can install it by running")
+            print("  sage -i notebook")
+            print("Alternatively, you can follow the instructions at")
+            print("  " + _system_jupyter_url)
+            print("to use Sage with an existing Jupyter notebook installation.")
+            raise SystemExit(1)
+        main(argv)
+
+
+class NotebookJupyterlab():
+    def print_banner(self):
+        print('Please wait while the Jupyterlab server starts...')
+
+    @classmethod
+    def print_help(cls):
+        cls(['help'])
+
+    def __init__(self, argv):
+        try:
+            from jupyterlab.labapp import main
+        except ImportError:
+            import traceback
+            traceback.print_exc()
+            print("Jupyterlab is not installed (at least not in this Sage installation).")
+            print("You can install it by running")
+            print("  sage -i jupyterlab")
+            print("Alternatively, you can follow the instructions at")
+            print("  " + _system_jupyter_url)
+            print("to use Sage with an existing Jupyterlab installation.")
+            raise SystemExit(1)
+        self.print_banner()
+        main(argv)
+
+
+class SageNBExport(NotebookJupyter):
+
+    def print_banner(self):
+        print('Please wait while the SageNB export server starts...')
+
+    @classmethod
+    def print_help(cls):
+        cls(['--help'])
+
+    def __init__(self, argv):
+        if argv:
+            SAGENB_EXPORT = 'sagenb-export'
+            os.execvp(SAGENB_EXPORT, [SAGENB_EXPORT] + argv)
+        argv += [
+            "--NotebookApp.nbserver_extensions={'sagenb_export.nbextension':True}",
+            "--NotebookApp.default_url='/sagenb'",
+        ]
+        super(SageNBExport, self).__init__(argv)
+
+
+description = \
+"""
+The Sage notebook launcher is used to start the notebook, and allows
+you to choose between different implementations. Any further command
+line options are passed to the respective notebook.
+"""
+
+help_help = \
+"""
+show this help message and exit. Can be combined with
+"--notebook=[...]" to see notebook-specific options
+"""
+
+epilog = \
+"""
+EXAMPLES:
+
+* Run default notebook on port 1234.
+
+      sage -n default --port=1234
+      sage -n --port=1234      # equivalent
+
+* Run Jupyter notebook in custom directory:
+
+      sage --notebook=jupyter --notebook-dir=/home/foo/bar
+
+* List available legacy Sage notebooks:
+
+      sage --notebook=export --list
+
+* Export a legacy Sage notebook as a Jupyter notebook:
+
+      sage --notebook=export --ipynb=Output.ipynb admin:10
+"""
+
+notebook_launcher = {
+    'default': NotebookJupyter,   # change this to change the default
+    'ipython': NotebookJupyter,
+    'jupyter': NotebookJupyter,
+    'jupyterlab': NotebookJupyterlab,
+    'export': SageNBExport,
+}
+
+notebook_names = ', '.join(notebook_launcher.keys())
+
+
+def make_parser():
+    """
+    The main parser handling the selection of the notebook.
+
+    Any arguments that are not parsed here are supposed to be handled
+    by the notebook implementation.
+    """
+    parser = argparse.ArgumentParser(
+        description=description, epilog=epilog,
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        add_help=False)
+    parser.add_argument('-h', '--help',
+                        dest='option_help', action='store_true',
+                        default=False,
+                        help=help_help)
+    parser.add_argument('--log', dest='log', default=None,
+                        help='one of [DEBUG, INFO, ERROR, WARNING, CRITICAL]')
+    default = None
+    for name, launcher in notebook_launcher.items():
+        if launcher == notebook_launcher['default'] and name != 'default':
+            default = name
+    if default is None:
+        raise RuntimeError('default launcher is defined but not known under a specific name')
+    parser.add_argument('--notebook',    # long style
+                        '-n',            # short style
+                        '-notebook',     # wtf style, we can't decide (legacy support)
+                        dest='notebook', type=str, nargs='?', const='default',
+                        help='The notebook to run [one of: {0}]. Default is {1}'.format(
+                            notebook_names, default))
+    return parser
+
+
+def trac_23428_browser_workaround():
+    """
+    Running 'sage -n" with the Jupyter notebook on Darwin fails to
+    open a browser automatically. See :trac:`23428`.
+    """
+    if sys.platform != 'darwin':
+        return
+    if not os.environ.get('BROWSER', False):
+        os.environ['BROWSER'] = 'open'
+
+
+@contextmanager
+def sage_doc_server():
+    from functools import partial
+    from http.server import SimpleHTTPRequestHandler, ThreadingHTTPServer
+    from threading import Thread
+    from sage.env import SAGE_DOC, SAGE_DOC_LOCAL_PORT as port
+
+    server = ThreadingHTTPServer(('127.0.0.1', int(port)),
+        partial(SimpleHTTPRequestHandler, directory=SAGE_DOC))
+
+    if port == '0':
+        port = str(server.server_address[1])
+        os.environ['SAGE_DOC_LOCAL_PORT'] = port
+
+    server_thread = Thread(target=server.serve_forever, name="sage_doc_server")
+    server_thread.start()
+    print(f'Sage doc server started running at http://127.0.0.1:{port}')
+
+    try:
+        yield
+    finally:
+        server.shutdown()
+        server_thread.join()
+        print(f'Sage doc server stopped runnning at http://127.0.0.1:{port}')
+
+
+if __name__ == '__main__':
+    parser = make_parser()
+    args, unknown = parser.parse_known_args(sys.argv[1:])
+    if unknown and unknown[0] == '--':
+        unknown = unknown[1:]
+    trac_23428_browser_workaround()
+    if args.log is not None:
+        import logging
+        level = getattr(logging, args.log.upper())
+        logger.setLevel(level=level)
+    logger.info('Main parser got arguments %s', args)
+    logger.info('Passing on to notebook implementation: %s', unknown)
+
+    if args.notebook == "sagenb":
+        logger.critical('cannot use the legacy notebook SageNB with Python 3')
+        print('The legacy notebook does not work under Python 3; '
+              'use the Jupyter notebook.')
+        print('See https://wiki.sagemath.org/Python3-Switch')
+        print('Use \"sage --notebook=export\" to export SageNB notebooks '
+              'to Jupyter')
+        sys.exit(1)
+
+    from sage.repl.ipython_kernel.install import SageKernelSpec
+    SageKernelSpec.check()
+
+    try:
+        launcher = notebook_launcher[args.notebook]
+    except KeyError:
+        logger.critical('unknown notebook: %s', args.notebook)
+        print('Error, notebook must be one of {0} but got {1}'.
+              format(notebook_names, args.notebook))
+        sys.exit(1)
+
+    if args.option_help:
+        if args.notebook == 'default':
+            parser.print_help()
+        else:
+            launcher.print_help()
+        sys.exit(0)
+
+    banner()
+
+    # Start a Sage doc server if the Sage documentation is available locally.
+    # See the corresponding code in src/sage/repl/ipython_kernel/kernel.py.
+
+    from sage.env import SAGE_DOC_SERVER_URL
+    from sage.features.sagemath import sagemath_doc_html
+
+    if SAGE_DOC_SERVER_URL:
+        print(f'Sage doc server is running at {SAGE_DOC_SERVER_URL}')
+        launcher(unknown)
+    elif sagemath_doc_html().is_present():
+        with sage_doc_server():
+            launcher(unknown)
+    else:
+        launcher(unknown)

passagemath_repl-10.4.62.data/scripts/sage-omega

@@ -0,0 +1,25 @@
+#!/bin/sh
+
+# We reuse the gdb pythonstartup script.
+PYTHONSTARTUP=`dirname $0`/sage-ipython
+export PYTHONSTARTUP
+echo $PYTHONSTARTUP
+if [ ! -d "$DOT_SAGE/valgrind" ]; then
+    mkdir "$DOT_SAGE/valgrind"
+fi
+
+LOG="$DOT_SAGE"/valgrind/sage-omega.%p
+echo "Log file is $LOG"
+
+OMEGA_FLAGS="--log-file=$LOG "; export OMEGA_FLAGS
+if [ "$SAGE_OMEGA_FLAGS" ]; then
+    echo "Overwriting omega flags with:"
+    echo $SAGE_OMEGA_FLAGS
+    OMEGA_FLAGS=$SAGE_OMEGA_FLAGS; export OMEGA_FLAGS
+else
+    echo "Using default flags:"
+    echo $OMEGA_FLAGS
+fi
+
+valgrind --tool=exp-omega $OMEGA_FLAGS sage-python -i
+

passagemath_repl-10.4.62.data/scripts/sage-preparse

@@ -0,0 +1,302 @@
+#!python
+"""
+Preparse .sage files and save the result to .sage.py files.
+
+AUTHOR:
+    -- William Stein (2005): first version
+    -- William Stein (2008): fix trac #2391 and document the code.
+    -- Dan Drake (2009): fix trac #5052
+    -- Dan Drake (2010-12-08): fix trac #10440
+    -- Johan S. R. Nielsen (2015-11-06): fix trac #17019
+"""
+
+import os
+import sys
+import re
+
+from sage.repl.preparse import preparse_file
+from sage.misc.temporary_file import atomic_write
+
+# The spkg/bin/sage script passes the files to be preparsed as
+# arguments (but remove sys.argv[0]).
+files = sys.argv[1:]
+
+# There must be at least 1 file or we display an error/usage message
+# and exit
+if not files:
+    print("""Usage: {} <file1.sage> <file2.sage>...
+Creates files file1.sage.py, file2.sage.py ... that are the Sage
+preparsed versions of file1.sage, file2.sage ...
+If a non-autogenerated .sage.py file with the same name exists, you will
+receive an error and the file will not be overwritten.""".format(sys.argv[0]))
+    sys.exit(1)
+
+# The module-scope variable contains a list of all files we
+# have seen while preparsing a given file.  The point of this
+# is that we want to avoid preparsing a file we have already
+# seen, since then infinite loops would result from mutual
+# recursive includes.
+files_so_far = []
+
+# This message is inserted in autogenerated files so that the reader
+# will know, and so we know it is safe to overwrite them.
+AUTOGEN_MSG = "# This file was *autogenerated* from the file "
+
+# We use this regexp to parse lines with load or attach statements.
+# Here's what it looks for:
+#
+# A (possibly empty) sequence of whitespace at the beginning of the
+# line, saved as a group named 'lws';
+#
+#   followed by
+#
+# the word "load" or "attach";
+#
+#   followed by
+#
+# a nonempty sequence of whitespace;
+#
+#   followed by
+#
+# whatever else is on the line, saved as a group named 'files'.
+#
+# We want to save the leading white space so that we can maintain
+# correct indentation in the preparsed file.
+load_or_attach = re.compile(r"^(?P<lws>\s*)(load|attach)\s+(?P<files>.*)$")
+
+def do_preparse(f, files_before=[]):
+    """
+    Preparse the file f and write the result out to a filename
+    with extension .sage.py.
+
+    INPUT:
+
+    - ``f`` -- string: the name of a file
+    - ``files_before`` -- list of strings of previous filenames loaded (to avoid circular loops)
+
+    OUTPUT: none (writes a file with extension .sage.py to disk)
+    """
+    if f in files_so_far:
+        return
+    files_so_far.append(f)
+    if not os.path.exists(f):
+        print("{}: File '{}' is missing".format(sys.argv[0], f))
+        return
+    if f.endswith('.py'):
+        return
+    if not f.endswith('.sage'):
+        print("{}: Unknown file type {}".format(sys.argv[0], f))
+        sys.exit(1)
+
+    fname = f + ".py"
+    if os.path.exists(fname):
+        with open(fname) as fin:
+            if AUTOGEN_MSG not in fin.read():
+                print("Refusing to overwrite existing non-autogenerated file {!r}."
+                      .format(os.path.abspath(fname)))
+                print("Please delete or move this file manually.")
+                sys.exit(1)
+
+    # TODO:
+    # I am commenting this "intelligence" out, since, e.g., if I change
+    # the preparser between versions this can cause problems.  This
+    # is an optimization that definitely isn't needed at present, since
+    # preparsing is so fast.
+    # Idea: I could introduce version numbers, though....
+    #if os.path.exists(fname) and os.path.getmtime(fname) >= os.path.getmtime(f):
+    #    return
+
+    # Finally open the file
+    with open(f) as fin:
+        F = fin.read()
+
+    # Check to see if a coding is specified in the .sage file. If it is,
+    # then we want to copy it over to the new file and not include it in
+    # the preprocessing. If both the first and second line have an
+    # encoding declaration, the second line's encoding will get used.
+
+    lines = F.splitlines()
+    coding = ''
+    for num, line in enumerate(lines[:2]):
+        if re.search(r"coding[:=]\s*([-\w.]+)", line):
+            coding = line + '\n'
+            F = '\n'.join(lines[:num] + lines[(num+1):])
+
+    # It is ** critical ** that all the preparser-stuff we put into
+    # the file are put after the module docstring, since
+    # otherwise the docstring will not be understood by Python.
+    i = find_position_right_after_module_docstring(F)
+    header, body = F[:i] , F[i:]
+    # Preparse the body
+    body = preparse_file(body)
+
+    # Check for "from __future__ import ..." statements. Those
+    # statements need to come at the top of the file (after the
+    # module-level docstring is okay), so we separate them from the
+    # body.
+    #
+    # Note: this will convert invalid Python to valid, because it will
+    # move all "from __future__ import ..." to the top of the file,
+    # even if they were not at the top originally.
+    future_imports, body = find_future_imports(body)
+
+    # Check for load/attach commands.
+    body = do_load_and_attach(body, f, files_before)
+
+    # The Sage library include line along with a autogen message
+    sage_incl = '%s%s\nfrom sage.all_cmdline import *   # import sage library\n'%(AUTOGEN_MSG, f)
+
+    # Finally, write out the result.  We use atomic_write to avoid
+    # race conditions (for example, the file will never be half written).
+    with atomic_write(fname) as f:
+        f.write(coding)
+        f.write(header)
+        f.write('\n')
+        f.write(future_imports)
+        f.write('\n')
+        f.write(sage_incl)
+        f.write('\n')
+        f.write(body)
+        f.write('\n')
+
+def find_position_right_after_module_docstring(G):
+    """
+    Return first position right after the module docstring of G, if it
+    has one.  Otherwise return 0.
+
+    INPUT:
+        G -- a string
+    OUTPUT:
+        an integer -- the index into G so that G[i] is right after
+                      the module docstring of G, if G has one.
+    """
+    # The basic idea below is that we look at each line first ignoring
+    # all empty lines and commented out lines.  Then we check to see
+    # if the next line is a docstring.  If so, we find where that
+    # docstring ends.
+    v = G.splitlines()
+    i = 0
+    while i < len(v):
+        s = v[i].strip()
+        if s and s[0] != '#':
+            break
+        i += 1
+    if i >= len(v):
+        # No module docstring --- entire file is commented out
+        return 0
+
+    # Now v[i] contains the first line of the first statement in the file.
+    # Is it a docstring?
+    n = v[i].lstrip()
+    if not (n[0] in ['"',"'"] or n[0:2] in ['r"',"r'"]):
+        # not a docstring
+        return 0
+
+    # First line is the module docstring.  Where does it end?
+    def pos_after_line(k):
+        return sum(len(v[j])+1 for j in range(k+1))
+
+    n = n.lstrip('r')  # strip leading r if there is one
+    if n[:3] in ["'''", '"""']:
+        quotes = n[:3]
+        # possibly multiline
+        if quotes in n[3:]:
+            return pos_after_line(i)
+        j = i+1
+        while j < len(v) and quotes not in v[j]:
+            j += 1
+        return pos_after_line(j)
+    else:
+        # it must be a single line; so add up the lengths of all lines
+        # including this one and return that
+        return pos_after_line(i)
+
+
+def find_future_imports(G):
+    """
+    Parse a file G as a string, looking for "from __future__ import ...".
+
+    Return a tuple: (the import statements, the file G with those
+    statements removed)
+
+    INPUT:
+        G -- a string; the contents of a file
+
+    This can only handle "from __future__ import ..." statements which
+    are completely on a single line: nothing of the form ::
+
+        from __future__ import \
+            print_function
+
+    or ::
+
+        from __future__ import (print_function,
+                                division)
+
+    This function will raise an error if it detects lines of these forms.
+    """
+    import_statements = []
+    # "from __future__ import ..." should not be indented.
+    m = re.search("^(from __future__ import .*)$", G, re.MULTILINE)
+    while m:
+        statement = m.group(0)
+        # If the import statement ends in a line continuation marker
+        # or if it contains a left parenthesis but not a right one,
+        # then the statement is not complete, so raise an error. (This
+        # is not a perfect check and some bad cases may slip through,
+        # like two left parentheses and only one right parenthesis,
+        # but they should be rare.)
+        if (statement[-1] == '\\' or
+            (statement.find('(') > -1 and statement.find(')') == -1)):
+            raise NotImplementedError('the Sage preparser can only preparse "from __future__ import ..." statements which are on a single line')
+        import_statements.append(statement)
+        G = G[:m.start()] + G[m.end():]
+        m = re.search("^(from __future__ import .*)$", G, re.MULTILINE)
+    return ('\n'.join(import_statements), G)
+
+
+def do_load_and_attach(G, file, files_before):
+    """
+    Parse a file G and replace load and attach statements with the
+    corresponding execfile() statements.
+
+    INPUT:
+        G -- a string; a file loaded in from disk
+        file -- the name of the file that contains the non-preparsed
+                version of G.
+        files_before -- list of files seen so far (don't recurse into
+                infinite loop)
+
+    OUTPUT:
+        string -- result of parsing load/attach statements in G, i.e.
+                  modified version of G with execfiles.
+    """
+    s = ''
+    for t in G.split('\n'):
+        z = load_or_attach.match(t)
+        if z:
+            files = z.group('files').split()
+            lws = z.group('lws')
+            for w in files:
+                name = w.replace(',', '').replace('"', '').replace("'", "")
+                if name in files_before:
+                   print("WARNING: not loading {} (in {}) again since would cause circular loop"
+                        .format(name, file))
+                   continue
+                if name.endswith('.sage'):
+                    do_preparse(name, files_before + [file])
+                    s += lws + "exec(compile(open({0}.py).read(), {0}.py, \
+                            'exec'))\n".format(name)
+                elif name.endswith('.py'):
+                    s += lws + "exec(compile(open({0}).read(), {0}, \
+                            'exec'))\n".format(name)
+        else:
+            s += t + '\n'
+    return s
+
+
+# Here we do the actual work.  We iterate over ever
+# file in the input args and create the corresponding
+# output file.
+for f in files:
+    do_preparse(f)