passagemath-categories 10.6.32__cp314-cp314t-musllinux_1_2_aarch64.whl

sage/interfaces/sagespawn.pyx

@@ -0,0 +1,308 @@
+# sage_setup: distribution = sagemath-categories
+# sage.doctest: optional - ptyprocess
+"""
+Sage wrapper around pexpect's ``spawn`` class and
+the ptyprocess's ``PtyProcess`` class.
+
+AUTHOR:
+
+- Jeroen Demeyer (2015-02-01): initial version, see :issue:`17686`.
+
+- Jeroen Demeyer (2015-12-04): add support for pexpect 4 + ptyprocess,
+  see :issue:`10295`.
+"""
+
+# ***************************************************************************
+#       Copyright (C) 2015 Jeroen Demeyer <jdemeyer@cage.ugent.be>
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 2 of the License, or
+# (at your option) any later version.
+#                  https://www.gnu.org/licenses/
+# ***************************************************************************
+
+from pexpect import *
+from ptyprocess import PtyProcess
+
+from cpython.ref cimport Py_INCREF
+
+IF UNAME_SYSNAME == "Linux" or UNAME_SYSNAME == "Darwin":
+
+    from libc.signal cimport *
+
+    from posix.signal cimport killpg
+    from posix.unistd cimport getpid, getpgid, fork
+
+ELSE:
+
+    def getpid():
+        return 0
+
+    def getpgid(x):
+        return 0
+
+    def fork():
+        return 0
+
+    def killpg(x):
+        return 0
+
+    cdef int SIGCONT = 0
+    cdef int SIGINT = 0
+    cdef int SIGHUP = 0
+    cdef int SIGTERM = 0
+    cdef int SIGKILL = 0
+
+from time import sleep
+
+from sage.cpython.string cimport str_to_bytes
+from sage.interfaces.process cimport ContainChildren
+
+
+class SageSpawn(spawn):
+    def __init__(self, *args, **kwds):
+        """
+        Spawn a subprocess in a pseudo-tty.
+
+        - ``*args``, ``**kwds`` -- see :class:`pexpect.spawn`
+
+        - ``name`` -- human-readable name for this process, used for
+          display purposes only
+
+        - ``quit_string`` -- (default: ``None``) if not ``None``, send
+          this string to the child process before killing it
+
+        EXAMPLES::
+
+            sage: from sage.interfaces.sagespawn import SageSpawn
+            sage: SageSpawn("sleep 1", name="Sleeping Beauty")
+            Sleeping Beauty with PID ... running ...
+        """
+        self.__name = kwds.pop("name", self.__class__.__name__)
+        self.quit_string = kwds.pop("quit_string", None)
+
+        kwds.setdefault("ignore_sighup", True)
+
+        # Use a *serious* read buffer of 4MiB, not the ridiculous 2000 bytes
+        # that pexpect uses by default.
+        kwds.setdefault("maxread", 4194304)
+
+        with ContainChildren(silent=True):
+            spawn.__init__(self, *args, **kwds)
+
+        self.delaybeforesend = None
+        self.delayafterread = None
+
+    def _spawnpty(self, args, **kwds):
+        """
+        Create an instance of :class:`SagePtyProcess`.
+
+        EXAMPLES::
+
+            sage: from sage.interfaces.sagespawn import SageSpawn
+            sage: s = SageSpawn("sleep 1")
+            sage: s.ptyproc
+            SagePtyProcess.spawn(...)
+        """
+        ptyproc = SagePtyProcess.spawn(args, **kwds)
+        ptyproc.quit_string = self.quit_string
+        return ptyproc
+
+    def __repr__(self):
+        """
+        A string representing this subprocess.
+
+        EXAMPLES::
+
+            sage: from sage.interfaces.sagespawn import SageSpawn
+            sage: s = SageSpawn("true", name="stupid process")
+            sage: s  # indirect doctest
+            stupid process with PID ... running .../true
+            sage: while s.isalive():  # Wait until the process finishes
+            ....:     sleep(float(0.1))
+            sage: s  # indirect doctest
+            stupid process finished running .../true
+        """
+        try:
+            cmd = " ".join(self.args)
+            if not self.terminated:
+                return "%s with PID %s running %s" % (self.__name, self.pid, cmd)
+            else:
+                return "%s finished running %s" % (self.__name, cmd)
+        except Exception:
+            return object.__repr__(self)
+
+    def _keep_alive(self):
+        """
+        Ensure that the child process does not get terminated, even if
+        all references to ``self`` are deleted.
+
+        This is needed in forked Sage processes: a forked process
+        should call this method and then delete all references to
+        ``self``.
+
+        EXAMPLES::
+
+            sage: from sage.interfaces.sagespawn import SageSpawn
+            sage: s = SageSpawn("sh", ["-c", "while true; do sleep 1; done"])
+            sage: s._keep_alive()
+            sage: pid = s.pid
+            sage: del s
+            sage: import gc
+            sage: _ = gc.collect()
+
+        All references to ``s`` have been deleted, but the process is
+        still running::
+
+            sage: from signal import SIGTERM
+            sage: os.kill(pid, SIGTERM)
+        """
+        Py_INCREF(self)
+
+    def expect_peek(self, *args, **kwds):
+        r"""
+        Like :meth:`expect` but restore the read buffer such that it
+        looks like nothing was actually read. The next reading will
+        continue at the current position.
+
+        EXAMPLES::
+
+            sage: from sage.interfaces.sagespawn import SageSpawn
+            sage: E = SageSpawn("sh", ["-c", "echo hello world"])
+            sage: _ = E.expect_peek("w")
+            sage: E.read().decode('ascii')
+            'hello world\r\n'
+        """
+        ret = self.expect(*args, **kwds)
+        self._before = self.buffer_type()
+        self._before.write(self.before + self.after + self.buffer)
+        return ret
+
+    def expect_upto(self, *args, **kwds):
+        r"""
+        Like :meth:`expect` but restore the read buffer starting from
+        the matched string. The next reading will continue starting
+        with the matched string.
+
+        EXAMPLES::
+
+            sage: from sage.interfaces.sagespawn import SageSpawn
+            sage: E = SageSpawn("sh", ["-c", "echo hello world"])
+            sage: _ = E.expect_upto("w")
+            sage: E.read().decode('ascii')
+            'world\r\n'
+        """
+        ret = self.expect(*args, **kwds)
+        self._before = self.buffer_type()
+        self._before.write(self.after + self.buffer)
+        return ret
+
+
+class SagePtyProcess(PtyProcess):
+    def close(self, force=None):
+        """
+        Quit the child process: send the quit string, close the
+        pseudo-tty and kill the process.
+
+        This function returns immediately, it doesn't wait for the
+        child process to die.
+
+        EXAMPLES::
+
+            sage: from sage.interfaces.sagespawn import SageSpawn
+            sage: s = SageSpawn("sleep 1000")
+            sage: s.close()
+            sage: while s.isalive():  # long time (5 seconds)
+            ....:     sleep(float(0.1))
+        """
+        if not self.closed:
+            if self.quit_string is not None:
+                try:
+                    # This can fail if the process already exited
+                    # PtyProcess.write takes bytes; ideally we would use
+                    # an encoding picked specifically for the target process
+                    # but the default (UTF-8) will do now, since I don't
+                    # think we have any non-ASCII quit_strings anyways.
+                    self.write(str_to_bytes(self.quit_string))
+                except (OSError, IOError):
+                    pass
+            self.fileobj.close()
+            self.fd = -1
+            self.closed = 1
+            self.terminate_async()
+
+    def terminate_async(self, interval=5.0):
+        """
+        Terminate the child process group asynchronously.
+
+        This function returns immediately, while the child is slowly
+        being killed in the background.
+
+        INPUT:
+
+        - ``interval`` -- (default: 5) how much seconds to wait between
+          sending two signals
+
+        EXAMPLES:
+
+        Run an infinite loop in the shell::
+
+            sage: from sage.interfaces.sagespawn import SageSpawn
+            sage: s = SageSpawn("sh", ["-c", "while true; do sleep 1; done"])
+
+        Check that the process eventually dies after calling
+        ``terminate_async``::
+
+            sage: s.ptyproc.terminate_async(interval=float(0.2))
+            sage: while True:
+            ....:     try:
+            ....:         os.kill(s.pid, 0)
+            ....:     except OSError:
+            ....:         sleep(float(0.1))
+            ....:     else:
+            ....:         break  # process got killed
+        """
+        cdef int pg, counter = 0
+        cdef int thispg = getpgid(getpid())
+        assert thispg != -1
+
+        with ContainChildren():
+            if fork():
+                # Parent process
+                return
+
+            # We need to avoid a race condition where the spawned
+            # process has not started up completely yet: we need to
+            # wait until the spawned process has changed its process
+            # group. See Issue #18741.
+            pg = getpgid(self.pid)
+            while pg == thispg:
+                counter += 1
+                if counter >= 20:
+                    # Something is seriously wrong, give up...
+                    raise RuntimeError("%r is not starting up" % self)
+                sleep(interval * 0.125)
+                pg = getpgid(self.pid)
+
+            # If we failed to determine the process group, probably
+            # this child is already dead...
+            if pg == -1:
+                return
+
+            # If any of these killpg() calls fail, it's most likely
+            # because the process is actually killed.
+            if killpg(pg, SIGCONT):
+                return
+            sleep(interval)
+            if killpg(pg, SIGINT):
+                return
+            sleep(interval)
+            if killpg(pg, SIGHUP):
+                return
+            sleep(interval)
+            if killpg(pg, SIGTERM):
+                return
+            sleep(interval)
+            if killpg(pg, SIGKILL):
+                return

sage/interfaces/tab_completion.py

@@ -0,0 +1,101 @@
+# sage_setup: distribution = sagemath-categories
+"""
+Mixin For Extra Tab Completions
+
+The :class:`ExtraTabCompletion` class helps you to extend the tab
+completions for objects. This is used in interfaces with third-party
+interpreters where we want, for example, ``gap.[TAB]`` to also list
+GAP commands and not only the Python methods of the gap interface. To
+use it, just inherit (usually by multiple inheritance) from
+:class:`ExtraTabCompletion` and implement a ``_tab_completion`` method
+that returns a list of strings. These strings are then included in the
+tab completions on instances. It is up to you to make these "fake"
+method names work, usually by implementing ``__getattr__``.
+
+EXAMPLES::
+
+    sage: from sage.interfaces.tab_completion import ExtraTabCompletion
+    sage: class Foo(ExtraTabCompletion, object):
+    ....:      def a(self):
+    ....:          return 1
+    ....:      def _tab_completion(self):
+    ....:          return ['c', 'd']
+    sage: f = Foo()
+    sage: f.b = 2
+    sage: sorted(dir(f))
+    [..., '_tab_completion', 'a', 'b', 'c', 'd']
+"""
+import builtins
+
+
+class ExtraTabCompletion:
+
+    def __dir__(self):
+        """
+        Add to the ``dir()`` output.
+
+        This is used by IPython to read off the tab completions.
+
+        EXAMPLES::
+
+            sage: from sage.interfaces.tab_completion import ExtraTabCompletion
+            sage: obj = ExtraTabCompletion()
+            sage: dir(obj)
+            Traceback (most recent call last):
+            ...
+            NotImplementedError: <class 'sage.interfaces.tab_completion.ExtraTabCompletion'> must implement _tab_completion() method
+        """
+        try:
+            tab_fn = self._tab_completion
+        except AttributeError:
+            raise NotImplementedError(
+                '{0} must implement _tab_completion() method'.format(self.__class__))
+        return dir(self.__class__) + list(self.__dict__) + tab_fn()
+
+
+def completions(s, globs):
+    """
+    Return a list of completions in the given context.
+
+    INPUT:
+
+    - ``s`` -- string
+
+    - ``globs`` -- string: object dictionary; context in which to
+      search for completions, e.g., :func:`globals()`
+
+    OUTPUT: list of strings
+
+    EXAMPLES::
+
+         sage: X.<x> = PolynomialRing(QQ)
+         sage: import sage.interfaces.tab_completion as s
+         sage: p = x**2 + 1
+         sage: s.completions('p.co',globals()) # indirect doctest
+         ['p.coefficient',...]
+
+         sage: s.completions('dic',globals()) # indirect doctest
+         ['dickman_rho', 'dict']
+    """
+    if not s:
+        raise ValueError('empty string')
+
+    if '.' not in s:
+        n = len(s)
+        v = [x for x in globs if x[:n] == s]
+        v += [x for x in builtins.__dict__ if x[:n] == s]
+    else:
+        i = s.rfind('.')
+        method = s[i + 1:]
+        obj = s[:i]
+        n = len(method)
+        try:
+            O = eval(obj, globs)
+            D = dir(O)
+            if not method:
+                v = [obj + '.' + x for x in D if x and x[0] != '_']
+            else:
+                v = [obj + '.' + x for x in D if x[:n] == method]
+        except Exception:
+            v = []
+    return sorted(set(v))

sage/misc/all__sagemath_categories.py

@@ -0,0 +1,78 @@
+# sage_setup: distribution = sagemath-categories
+
+from sage.misc.all__sagemath_objects import *
+
+from sage.misc.html import html, pretty_print_default
+
+from sage.misc.mathml import mathml
+
+from sage.misc.table import table
+
+from sage.misc.map_threaded import map_threaded
+
+from sage.misc.mrange import xmrange, mrange, xmrange_iter, mrange_iter, cartesian_product_iterator
+
+from sage.misc.defaults import (set_default_variable_name,
+                                series_precision, set_series_precision)
+
+
+from sage.misc.functional import (additive_order,
+                                  base_ring,
+                                  base_field,
+                                  basis,
+                                  category,
+                                  charpoly,
+                                  characteristic_polynomial,
+                                  coerce,
+                                  cyclotomic_polynomial,
+                                  decomposition,
+                                  denominator,
+                                  det,
+                                  dimension,
+                                  dim,
+                                  discriminant,
+                                  disc,
+                                  eta,
+                                  fcp,
+                                  gen,
+                                  gens,
+                                  hecke_operator,
+                                  image,
+                                  integral, integrate,
+                                  integral_closure,
+                                  interval,
+                                  xinterval,
+                                  is_even,
+                                  is_odd,
+                                  kernel,
+                                  krull_dimension,
+                                  lift,
+                                  log as log_b,
+                                  minimal_polynomial,
+                                  minpoly,
+                                  multiplicative_order,
+                                  ngens,
+                                  norm,
+                                  numerator,
+                                  numerical_approx,
+                                  n, N,
+                                  objgens,
+                                  objgen,
+                                  order,
+                                  rank,
+                                  regulator,
+                                  round,
+                                  quotient,
+                                  quo,
+                                  isqrt,
+                                  squarefree_part,
+                                  sqrt,
+                                  symbolic_sum as sum,
+                                  symbolic_prod as product,
+                                  transpose)
+
+from sage.misc.latex import LatexExpr, latex, view
+
+from sage.misc.fpickle import pickle_function, unpickle_function
+
+from sage.misc.persist import unpickle_global

sage/misc/allocator.pxd

@@ -0,0 +1,6 @@
+# sage_setup: distribution = sagemath-categories
+from cpython.object cimport *
+
+cdef hook_tp_functions_type(object t, newfunc tp_new, destructor tp_dealloc, bint useGC)
+
+cdef hook_tp_functions(object global_dummy, newfunc tp_new, destructor tp_dealloc, bint useGC)

sage/misc/allocator.pyx

@@ -0,0 +1,47 @@
+# sage_setup: distribution = sagemath-categories
+from cpython.ref cimport Py_INCREF
+
+cdef _hook_tp_functions_type(PyTypeObject *t, newfunc tp_new, destructor tp_dealloc, bint useGC):
+    """
+    Initialize the fast integer creation functions.
+    """
+    cdef long flag
+
+    # By default every object created in Pyrex is garbage
+    # collected. This means it may have references to other objects
+    # the Garbage collector has to look out for. We remove this flag
+    # as the only reference an Integer has is to the global Integer
+    # ring. As this object is unique we don't need to garbage collect
+    # it as we always have a module level reference to it. If another
+    # attribute is added to the Integer class this flag removal so as
+    # the alloc and free functions may not be used anymore.
+    # This object will still be reference counted.
+    if not useGC:
+        flag = Py_TPFLAGS_HAVE_GC
+        t.tp_flags = <long>(t.tp_flags & (~flag))
+
+    # Finally replace the functions called when an Integer needs
+    # to be constructed/destructed.
+    t.tp_new = tp_new
+    t.tp_dealloc = tp_dealloc
+
+
+cdef hook_tp_functions_type(object tp, newfunc tp_new, destructor tp_dealloc, bint useGC):
+    cdef PyTypeObject *t = <PyTypeObject *>tp
+    _hook_tp_functions_type(t, tp_new, tp_dealloc, useGC)
+
+
+cdef hook_tp_functions(object global_dummy, newfunc tp_new, destructor tp_dealloc, bint useGC):
+    """
+    Initialize the fast integer creation functions.
+    """
+    # Make sure this never, ever gets collected.
+    # This is not necessary for cdef'ed variables as the global
+    # dummy integer, as such objects do not get automatically collected.
+    # In fact there is no obvious reason to prevent collection when Sage quits
+    # and we are certain no further call to the allocation function will be
+    # made; so this could be removed when the code is clean enough.
+    Py_INCREF(global_dummy)
+
+    cdef PyTypeObject* t = Py_TYPE(global_dummy)
+    _hook_tp_functions_type(t, tp_new, tp_dealloc, useGC)

sage/misc/binary_tree.pxd

@@ -0,0 +1,29 @@
+# sage_setup: distribution = sagemath-categories
+cdef struct binary_tree_node:
+    int key
+    binary_tree_node *left
+    binary_tree_node *right
+    void *value
+
+# cdef binary_tree_node *BinaryTreeNode(int, object)
+# cdef void free_binary_tree_node(binary_tree_node *)
+# cdef void binary_tree_dealloc(binary_tree_node *)
+# cdef void binary_tree_insert(binary_tree_node *self, int, object)
+# cdef object binary_tree_get(binary_tree_node *, int)
+# cdef object binary_tree_delete(binary_tree_node *, int)
+# cdef binary_tree_node *binary_tree_left_excise(binary_tree_node *)
+# cdef binary_tree_node *binary_tree_right_excise(binary_tree_node *)
+# cdef binary_tree_node *binary_tree_head_excise(binary_tree_node *)
+# cdef object binary_tree_list(binary_tree_node *, int)
+
+
+# cdef int LIST_PREORDER, LIST_POSTORDER, LIST_INORDER, LIST_KEYS, LIST_VALUES
+# LIST_PREORDER  = 1
+# LIST_INORDER = 2
+# LIST_POSTORDER = 4
+# LIST_KEYS = 8
+# LIST_VALUES = 16
+
+
+cdef class BinaryTree:
+    cdef binary_tree_node *head