passagemath-repl 10.4.62__py3-none-any.whl

passagemath_repl-10.4.62.data/scripts/sage-cachegrind

@@ -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-cachegrind.%p
+echo "Log file is $LOG"
+
+CACHEGRIND_FLAGS="--log-file=$LOG "; export CACHEGRIND_FLAGS
+if [ "$SAGE_CACHEGRIND_FLAGS" ]; then
+    echo "Overwriting cachegrind flags with:"
+    echo $SAGE_CACHEGRIND_FLAGS
+    CACHEGRIND_FLAGS=$SAGE_CACHEGRIND_FLAGS; export CACHEGRIND_FLAGS
+else
+    echo "Using default flags:"
+    echo $CACHEGRIND_FLAGS
+fi
+
+valgrind --tool=cachegrind $CACHEGRIND_FLAGS sage-python -i
+

passagemath_repl-10.4.62.data/scripts/sage-callgrind

@@ -0,0 +1,16 @@
+#!/bin/sh
+
+if [ ! -d "$DOT_SAGE/valgrind" ]; then
+    mkdir "$DOT_SAGE/valgrind"
+fi
+LOG="$DOT_SAGE"/valgrind/sage-callgrind.%p
+
+CALLGRIND_FLAGS="--callgrind-out-file=$LOG "
+if [ "$SAGE_CALLGRIND_FLAGS" ]; then
+    echo "Overwriting callgrind flags with: $SAGE_CALLGRIND_FLAGS"
+    CALLGRIND_FLAGS=$SAGE_CALLGRIND_FLAGS
+ else
+    echo "Using default flags: $CALLGRIND_FLAGS"
+fi
+
+valgrind --tool=callgrind $CALLGRIND_FLAGS sage-ipython "$@" -i

passagemath_repl-10.4.62.data/scripts/sage-cleaner

@@ -0,0 +1,230 @@
+#!python
+
+#*****************************************************************************
+# This is the sage monitor *daemon*, which cleans up after Sage.
+# Some things that it cleans up:
+#   * $DOT_SAGE/temp/HOSTNAME/pid directories
+#   * Processes that Sage spawns.  If a copy of Sage isn't
+#     running, then any process it spawned should have its
+#     process group killed
+#*****************************************************************************
+#       Copyright (C) 2005, 2006, 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.
+#                  http://www.gnu.org/licenses/
+#*****************************************************************************
+
+
+import os, shutil, sys, time, socket, errno, signal, atexit
+
+
+HOSTNAME = os.environ.get('HOSTNAME', socket.gethostname())
+DOT_SAGE = os.environ['DOT_SAGE']
+
+SAGE_TMP_ROOT = os.path.join(DOT_SAGE, 'temp', HOSTNAME)
+logfile = os.path.join(SAGE_TMP_ROOT, 'cleaner.log')
+pidfile = os.path.join(SAGE_TMP_ROOT, 'cleaner.pid')
+# pidfile used by earlier versions of sage-cleaner (before #15457)
+old_pidfile = os.path.join(DOT_SAGE, 'temp', 'cleaner-%s.pid'%HOSTNAME)
+
+import logging
+logger = logging.getLogger(__name__)
+
+
+def mkdir_p(path):
+    """
+    A "mkdir -p" command that makes intermediate directories if necessary
+    """
+    try:
+        os.makedirs(path)
+    except OSError:
+        if not os.path.isdir(path):
+            raise
+
+
+def rm_rf(file_or_path):
+    """
+    Force recursive delete, ignoring errors.
+    """
+    try:
+        os.unlink(file_or_path)
+    except OSError as e:
+        if e.errno == errno.EISDIR or e.errno == errno.EPERM:
+            shutil.rmtree(file_or_path, ignore_errors=True)
+
+
+def is_running(pid):
+    """
+    Return True if and only if there is a process with id pid running.
+    """
+    try:
+        os.kill(pid,0)
+        return True
+    except OSError:
+        return False
+
+
+def cleanup():
+    tmp_dirs = os.listdir(SAGE_TMP_ROOT)
+    try:
+        tmp_dirs.remove('cleaner.pid')
+        tmp_dirs.remove('cleaner.log')
+    except ValueError:
+        logger.error('No cleaner pid/log in SAGE_TMP_ROOT')
+    # Convert strings to integers
+    pid_list = []
+    for dir_entry in tmp_dirs:
+        try:
+            pid_list.append(int(dir_entry))
+        except ValueError:
+            badfile = os.path.join(SAGE_TMP_ROOT, dir_entry)
+            logger.warning('File %s must not be in SAGE_TMP_ROOT, deleting', badfile)
+            rm_rf(badfile)
+
+    logger.info("Checking PIDs %s", pid_list)
+    for parent_pid in pid_list:
+        try:
+            if not is_running(parent_pid):
+                logger.info("Process %s is no longer running, so we clean up", parent_pid)
+                dir_name = os.path.join(SAGE_TMP_ROOT, str(parent_pid))
+                spawned_processes = os.path.join(dir_name, 'spawned_processes')
+                if not os.path.isfile(spawned_processes) \
+                   or kill_spawned_jobs(spawned_processes, parent_pid):
+                    logger.info('Deleting %s', dir_name)
+                    rm_rf(dir_name)
+        except Exception:
+            logger.error("Exception while cleaning up PID %s:", parent_pid, exc_info=True)
+
+    return len(pid_list)
+
+def cleanup_cruft():
+    """ remove directories leftover from improper shutdown """
+    tmp_dirs = os.listdir(SAGE_TMP_ROOT)
+    for dir_entry in tmp_dirs:
+        baddir = os.path.join(SAGE_TMP_ROOT, dir_entry)
+        if os.path.isdir(baddir):
+            logger.warning('Removing old directory %s from SAGE_TMP_ROOT', baddir)
+            rm_rf(baddir)
+
+def kill_spawned_jobs(jobfile, parent_pid):
+    logger.info("Killing %s's spawned jobs", parent_pid)
+    killed_them_all = True
+    for job in open(jobfile).readlines():
+        try:
+            pid, cmd = job.strip().split(' ', 1)
+            pid = int(pid)
+            logger.info("--> Killing %r with PID %s and parent PID %s", cmd, pid, parent_pid)
+        except Exception:
+            logger.error("Exception while processing job %r from %s, ignoring", job, jobfile)
+            continue
+        try:
+            pgrp = os.getpgid(pid)
+            logger.info("--> Killing process group %s", pgrp)
+            os.killpg(pgrp, signal.SIGKILL)
+        except OSError:
+            pass
+        if is_running(pid):
+            logger.error("--> Failed to kill %s", pid)
+            # try again later
+            killed_them_all = False
+    return killed_them_all
+
+
+def exit_handler():
+    logger.info("Removing pidfile and logfile")
+    rm_rf(pidfile)
+    rm_rf(logfile)
+
+
+def setup_daemon():
+    mkdir_p(SAGE_TMP_ROOT)
+
+    logger.setLevel(logging.DEBUG)
+    h = logging.StreamHandler()                # log to stderr
+    h.setLevel(logging.DEBUG)
+    logger.addHandler(h)
+    h = logging.FileHandler(filename=logfile)  # log to logfile
+    h.setLevel(logging.INFO)
+    logger.addHandler(h)
+
+    logger.info("SAGE_TMP_ROOT = %s", SAGE_TMP_ROOT)
+
+    # Check old pidfile (to allow old and new sage-cleaners to peacefully coexist)
+    try:
+        pid = int(open(old_pidfile).read())
+    except (IOError, ValueError):
+        pass
+    else:
+        if is_running(pid):
+            logger.info("old sage-cleaner is already running with PID %s, exiting", pid)
+            sys.exit(0)
+
+    try:
+        pid = int(open(pidfile).read())
+    except (IOError, ValueError):
+        pass
+    else:
+        if is_running(pid):
+            logger.info("sage-cleaner is already running with PID %s, exiting", pid)
+            sys.exit(0)
+    with open(pidfile, 'w') as f:
+        f.write(str(os.getpid()))  # initialize pid file
+    atexit.register(exit_handler)
+
+
+def fix_old_mistakes():
+    """
+    Experience is simply the name we give our mistakes.
+    """
+    # inconsistently escaped hyphens with underscores (https://github.com/sagemath/sage/issues/14055)
+    wrong_hostname = HOSTNAME.replace('-','_').replace('/','_').replace('\\','_')
+    wrong_sage_tmp_root = os.path.join(DOT_SAGE, 'temp', wrong_hostname)
+    if wrong_sage_tmp_root != SAGE_TMP_ROOT and os.path.exists(wrong_sage_tmp_root):
+        logger.warning('Deleting invalid temp dir %s', wrong_sage_tmp_root)
+        rm_rf(wrong_sage_tmp_root)
+
+    # SAGE_TMP in DOT_SAGE/tmp instead of DOT_SAGE/temp
+    import glob
+    old_root =  glob.glob(os.path.join(DOT_SAGE, 'tmp', HOSTNAME+'-*'))
+    if wrong_hostname != HOSTNAME:
+        old_root += glob.glob(os.path.join(DOT_SAGE, 'tmp', wrong_hostname+'-*'))
+    for old_tmp in old_root:
+        logger.warning('Deleting invalid temp dir %s', old_tmp)
+        rm_rf(old_tmp)
+
+    # PID file before it was moved into SAGE_TMP_ROOT
+    rm_rf(old_pidfile)
+
+
+if __name__ == '__main__':
+    setup_daemon()
+    fix_old_mistakes()
+    logger.info("Starting sage-cleaner with PID %s", os.getpid())
+    cleanup_cruft()
+
+    if len(sys.argv) > 1:
+        wait = int(sys.argv[1])
+    else:
+        wait = 10
+
+    # Initial cleanup, ignore time
+    running_sages = cleanup()
+    cleanup_time = 0.0
+    count = 1
+
+    # In the first 10 iterations, continue anyway (even if there are
+    # no Sage processes running) because it can happen that Sage is
+    # not yet started.
+    while count < 10 or running_sages > 0:
+        # Time to wait = "wait" plus 20 times the time of last cleanup().
+        # This ensures that sage-cleaner causes a load of at most 5%.
+        time.sleep(wait + 20*cleanup_time)
+        count += 1
+        t0 = time.time()
+        running_sages = cleanup()
+        cleanup_time = time.time() - t0
+        logger.debug("cleanup() #{:d} took {:.2f}s".format(count, cleanup_time))
+
+    logger.info("sage-cleaner is finished")

passagemath_repl-10.4.62.data/scripts/sage-coverage

@@ -0,0 +1,327 @@
+#!python
+import os
+import sys
+from tokenize import (NEWLINE, COMMENT, INDENT, DEDENT, STRING, NL,
+                      NAME, OP, generate_tokens)
+import argparse
+
+parser = argparse.ArgumentParser(description='Look into Sage files for wrong doctests.')
+parser.add_argument('filename', type=str, nargs='*', help='filename or a directory')
+parser.add_argument('--all', action='store_true', help='give summary info about all files in the Sage library')
+parser.add_argument('--only-bad', action='store_true', help='only print info for bad formatted files')
+parser.add_argument('--summary', action='store_true', help='only print a short summary')
+
+args = parser.parse_args()
+
+
+def coverage_all(directory):
+    os.chdir(directory)
+    r = os.popen('sage-coverage * | grep SCORE').readlines()
+
+    s = []
+    scr = 0
+    total = 0
+    for x in r:
+        y = x.lstrip('SCORE ')
+        i = y.rfind(' of ')
+        j = y.rfind(')')
+        n = int(y[i+4:j])
+
+        i = y.rfind(':')
+        j = y.rfind('%')
+        scr += float(y[i+1:j]) * float(n)
+
+        total += n
+
+        s.append(y)
+
+    print(''.join(s))
+
+    # Issue #5859: Don't crash if there isn't anything to test.
+    score = 100.0
+    if total != 0:
+        score = (float(scr) / total)
+
+    print("Overall weighted coverage score: {:.1f}%".format(score))
+    print("Total number of functions: {}".format(total))
+
+    # Print up to 3 doctest coverage goals.
+    i = 0
+    for goal in [70, 75, 80, 85, 90, 95, 99]:
+        if score < goal:
+            i += 1
+            if i > 3: break
+            need = int((goal*total - scr)/100.0)
+            print("We need {:>4} more function{} to get to {}% coverage."
+                  .format(need, "" if (need == 1) else "s", goal))
+
+if args.all:
+    if not args.filename:
+        coverage_all(os.path.join(os.environ["SAGE_SRC"], 'sage'))
+    elif len(args.filename) == 1:
+        coverage_all(args.filename[0])
+    else:
+        print("sage-coverage: error: --all only accepts one filename argument")
+        sys.exit(1)
+    sys.exit(0)
+
+if not args.filename:
+    print("sage-coverage: error: if --all is not given, at least one filename argument is expected")
+    sys.exit(1)
+
+# Collect coverage results for one file
+class CoverageResults:
+    def __init__(self, filename=""):
+        """
+        INPUT:
+
+        - ``filename`` -- name of the file, only for display purposes.
+        """
+        self.no_doc = []
+        self.no_test = []
+        self.good = []
+        self.possibly_wrong = []
+        self.filename = filename
+
+    def report(self):
+        """
+        Print coverage results.
+        """
+        num_functions = len(self.good) + len(self.no_doc) + len(self.no_test)
+        if not num_functions:
+            print("No functions in", self.filename)
+            return
+
+        score = (100.0 * len(self.good)) / float(num_functions)
+
+        print("SCORE {}: {:.1f}% ({} of {})".format(self.filename, score, len(self.good), num_functions))
+
+        if self.no_doc:
+            print("\nMissing documentation:")
+            for f in self.no_doc:
+                print("     *", f)
+        if self.no_test:
+            print("\nMissing doctests:")
+            for f in self.no_test:
+                print("     *", f)
+
+        if self.possibly_wrong:
+            print("\nPossibly wrong (function name doesn't occur in doctests):")
+            for f in self.possibly_wrong:
+                print("     *", f)
+
+
+    def handle_function(self, name, fullname, docstring):
+        """
+        Check coverage of one function and store result.
+
+        INPUT:
+
+        - ``name`` -- bare function name (e.g. "foo")
+
+        - ``fullname`` -- complete function definition (e.g. "def foo(arg=None)")
+
+        - ``docstring`` -- the docstring, or ``None`` if there is no docstring
+        """
+        # Skip certain names
+        if name in ['__dealloc__', '__new__', '_']:
+            return
+
+        if not docstring:
+            self.no_doc.append(fullname)
+            return
+
+        if "pytest" in docstring:
+            self.good.append(fullname)
+            return
+
+        if "sage: " not in docstring:
+            self.no_test.append(fullname)
+            return
+
+        # If the name is of the form _xxx_, then the doctest is always
+        # considered indirect.
+        if name[0] == "_" and name[-1] == "_":
+            is_indirect = True
+        else:
+            is_indirect = "indirect doctest" in docstring
+
+        if not is_indirect and not name in docstring:
+            self.possibly_wrong.append(fullname)
+        self.good.append(fullname)
+
+
+    def check_file(self, f):
+        """
+        Check the coverage of one file.
+
+        INPUT:
+
+        - ``f``: an open file
+
+        OUTPUT: ``self``
+        """
+        # Where are we in a function definition?
+        BEGINOFLINE = 0   # Beginning of new logical line
+        UNKNOWN = -99     # Not at all in a function definition
+        DEFNAMES = 1      # In function definition before first open paren
+        DEFARGS = 2       # In function arguments or between closing paren and final colon
+        DOCSTRING = -1    # Looking for docstring
+
+        state = BEGINOFLINE
+
+        # Previous token type seen
+        prevtyp = NEWLINE
+
+        # Indentation level
+        indent = 0
+
+        # Indentation level of last "def" statement
+        # or None if no such statement.
+        defindent = None
+
+        for (typ, tok, start, end, logical_line) in generate_tokens(f.readline):
+            # Completely ignore comments or continuation newlines
+            if typ == COMMENT or typ == NL:
+                continue
+
+            # Handle indentation
+            if typ == INDENT:
+                indent += 1
+                continue
+            elif typ == DEDENT:
+                indent -= 1
+                if (defindent is not None and indent <= defindent):
+                    defindent = None
+                continue
+
+            # Check for "def" or "cpdef" ("cdef" functions don't need to be documented).
+            # Skip nested functions (with indent > defindent).
+            if state == BEGINOFLINE:
+                if typ == NAME and (tok in ["def", "cpdef"]) and (defindent is None or indent <= defindent):
+                    state = DEFNAMES
+                    deffullname = "line %s: "%start[0]
+                    defparen = 0  # Number of open parentheses
+                else:
+                    state = UNKNOWN
+
+            if state == DOCSTRING:
+                if typ != NEWLINE:
+                    docstring = None
+                    if typ == STRING:
+                        docstring = tok
+                    self.handle_function(defname, deffullname, docstring)
+                    state = UNKNOWN
+
+            if state == DEFNAMES:
+                if typ == NAME:
+                    if tok == "class":  # Make sure that cdef classes are ignored
+                        state = UNKNOWN
+                    # Last NAME token before opening parenthesis is
+                    # the function name.
+                    defname = tok
+                elif tok == '(':
+                    state = DEFARGS
+                else:
+                    state = UNKNOWN
+
+            if state == DEFARGS:
+                if tok == '(':
+                    defparen += 1
+                elif tok == ')':
+                    defparen -= 1
+                elif defparen == 0 and tok == ':':
+                    state = DOCSTRING
+                    defindent = indent
+                elif typ == NEWLINE:
+                    state = UNKNOWN
+
+            if state > 0:
+                # Append tok string to deffullname
+                if prevtyp == NAME and typ == NAME:
+                    deffullname += ' '
+                elif prevtyp == OP and deffullname[-1] in ",":
+                    deffullname += ' '
+                deffullname += tok
+
+            # New line?
+            if state == UNKNOWN and typ == NEWLINE:
+                state = BEGINOFLINE
+
+            prevtyp = typ
+
+        return self
+
+
+# Data reported by --summary
+good           = 0
+no_doc         = 0
+no_test        = 0
+possibly_wrong = 0
+bad_files      = []
+
+first = True
+
+
+def go(filename):
+    r"""
+    If ``filename`` is a file, launch the inspector on this file. If
+    ``filename`` is a directory then recursively launch this function on the
+    files it contains.
+    """
+    if os.path.isdir(filename):
+        for F in sorted(os.listdir(filename)):
+            go(os.path.join(filename, F))
+    if not os.path.exists(filename):
+        print("File %s does not exist."%filename, file=sys.stderr)
+        sys.exit(1)
+
+    if not (filename.endswith('.py')
+            or filename.endswith('.pyx')
+            or filename.endswith('.sage')):
+        return
+
+    # Filter pytest files which are not supposed to have doctests
+    if filename.endswith('_test.py'):
+        return
+
+    with open(filename, 'r') as f:
+        cr = CoverageResults(filename).check_file(f)
+    bad = cr.no_doc or cr.no_test or cr.possibly_wrong
+
+    # Update the global variables
+    if args.summary:
+        global good, no_doc, no_test, possibly_wrong, bad_files
+        no_doc         += len(cr.no_doc)
+        no_test        += len(cr.no_test)
+        possibly_wrong += len(cr.possibly_wrong)
+        good           += len(cr.good)
+        if bad:
+            bad_files.append(filename)
+        return
+    if not bad and args.only_bad:
+        return
+
+    global first
+    if first:
+        print('-' * 72)
+        first = False
+
+    cr.report()  # Print the report
+    print('-' * 72)
+
+
+for arg in args.filename:
+    go(arg)
+
+if args.summary:
+    num_functions = good + no_doc + no_test
+    score = (100.0 * good) / float(num_functions)
+    print("Global score: {:.1f}% ({} of {})\n".format(score, good, num_functions))
+    print("{} files with wrong documentation".format(len(bad_files)))
+    print("{} functions with no doc".format(no_doc))
+    print("{} functions with no test".format(no_test))
+    print("{} doctest are potentially wrong".format(possibly_wrong))
+    print("\nFiles with wrong documentation:")
+    print("-------------------------------")
+    print("\n".join("  {}".format(filename) for filename in bad_files))

passagemath_repl-10.4.62.data/scripts/sage-eval

@@ -0,0 +1,14 @@
+#!python
+
+import sys
+from sage.all import *
+try:
+    from sage.calculus.predefined import x
+except ImportError:
+    pass
+from sage.repl.preparse import preparse
+
+if len(sys.argv) > 1:
+    s = preparse(" ".join(sys.argv[1:]))
+    eval(compile(s,'<cmdline>','exec'))
+