passagemath-pari 10.6.32__cp314-cp314t-macosx_13_0_arm64.whl

PARIKernel/__init__.py

@@ -0,0 +1,2 @@
+# sage_setup: distribution = sagemath-pari
+__version__ = "1.4.3"

PARIKernel/__main__.py

@@ -0,0 +1,5 @@
+# sage_setup: distribution = sagemath-pari
+from .kernel import PARIKernel
+
+from ipykernel.kernelapp import IPKernelApp
+IPKernelApp.launch_instance(kernel_class=PARIKernel)

PARIKernel/io.pxd

@@ -0,0 +1,7 @@
+# sage_setup: distribution = sagemath-pari
+from .paridecl cimport PariOUT
+
+cdef class PARIKernelIO(object):
+    cdef PariOUT pari_out
+    cdef PariOUT pari_err
+    cdef readonly stdout_stream, stderr_stream

PARIKernel/io.pyx

@@ -0,0 +1,84 @@
+# sage_setup: distribution = sagemath-pari
+#cython: language_level=3
+#
+# Helper class to manage I/O between PARI and the Jupyter client
+#
+# Copyright (C) 2015 Jeroen Demeyer
+#
+# 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 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+
+from .paridecl cimport pariOut, pariErr
+from ipykernel.iostream import OutStream
+
+
+cdef extern from "Python.h":
+    unicode PyUnicode_FromString(const char *)
+    unicode PyUnicode_FromStringAndSize(const char *, Py_ssize_t)
+
+# Unique PARIKernelIO object
+cdef PARIKernelIO io
+
+
+cdef void out_putch(char c) noexcept with gil:
+    io.stdout_stream.write(PyUnicode_FromStringAndSize(&c, 1))
+
+cdef void out_puts(const char* s) noexcept with gil:
+    io.stdout_stream.write(PyUnicode_FromString(s))
+
+cdef void out_flush() noexcept with gil:
+    io.stdout_stream.flush()
+
+cdef void err_putch(char c) noexcept with gil:
+    io.stderr_stream.write(PyUnicode_FromStringAndSize(&c, 1))
+
+cdef void err_puts(const char* s) noexcept with gil:
+    io.stderr_stream.write(PyUnicode_FromString(s))
+
+cdef void err_flush() noexcept with gil:
+    io.stderr_stream.flush()
+
+
+cdef class PARIKernelIO(object):
+    def __cinit__(self):
+        self.pari_out.putch = out_putch
+        self.pari_out.puts = out_puts
+        self.pari_out.flush = out_flush
+        self.pari_err.putch = err_putch
+        self.pari_err.puts = err_puts
+        self.pari_err.flush = err_flush
+
+    def __init__(self, kernel):
+        global io
+        if io is not None:
+            raise RuntimeError("cannot create more than one PARIKernelIO object")
+        io = self
+
+        global pariOut, pariErr
+        pariOut = &self.pari_out
+        pariErr = &self.pari_err
+
+        self.stdout_stream = OutStream(kernel.session,
+                kernel.iopub_socket, "stdout")
+        self.stderr_stream = OutStream(kernel.session,
+                kernel.iopub_socket, "stderr")
+
+    def set_parent(self, parent):
+        self.stdout_stream.set_parent(parent)
+        self.stderr_stream.set_parent(parent)
+
+    def flush(self):
+        self.stdout_stream.flush()
+        self.stderr_stream.flush()

PARIKernel/kernel.pyx

@@ -0,0 +1,260 @@
+# sage_setup: distribution = sagemath-pari
+# distutils: include_dirs = READLINE_INCDIR
+# distutils: library_dirs = READLINE_LIBDIR
+# distutils: extra_link_args = READLINE_LIBEXTRA
+# distutils: libraries = readline
+#cython: language_level=3
+#
+# Jupyter kernel for PARI/GP
+#
+# Copyright (C) 2015-2016 Jeroen Demeyer
+#
+# 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 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+
+from .paridecl cimport *
+from .io cimport PARIKernelIO
+from libc.setjmp cimport *
+from libc.string cimport memset, strncmp
+from ipykernel.kernelbase import Kernel
+from libc.signal cimport SIGALRM, SIGINT
+from posix.signal cimport sigaction, sigaction_t
+import PARIKernel
+
+cdef extern from "readline/readline.h":
+    pass
+
+DEF PARISIZE = 2**27
+DEF PRIMELIMIT = 500000
+
+
+# Global setjmp() context for error handling
+cdef sigjmp_buf context
+
+cdef void pari_recover(long numerr) noexcept nogil:
+    siglongjmp(context, numerr)
+
+# Global PARI readline interface
+cdef pari_rl_interface pari_rl
+
+# Support for SVG plotting (if compiled in)
+try:
+    from .svg import init_svg
+except ImportError:
+    def init_svg(self):
+        pass
+
+
+# Helper functions
+cdef extern from "Python.h":
+    unicode PyUnicode_FromString(const char*)
+
+
+cdef inline PyUnicode_FromGEN(GEN g):
+    cdef char* s = GENtostr(g)
+    cdef object pystr = PyUnicode_FromString(s)
+    pari_free(s)
+    return pystr
+
+
+def pari_short_version():
+    cdef unsigned long mask = (1<<PARI_VERSION_SHIFT) - 1
+    cdef unsigned long n = paricfg_version_code
+
+    cdef unsigned long patch = n & mask
+    n >>= PARI_VERSION_SHIFT
+    cdef unsigned long minor = n & mask
+    n >>= PARI_VERSION_SHIFT
+    cdef unsigned long major = n
+    return "{}.{}.{}".format(major, minor, patch)
+
+
+cdef inline bint is_keyword_char_python(s) except -1:
+    """
+    Given a Python single-character string ``s``, is it a PARI
+    keyword character?
+    """
+    cdef long c
+    try:
+        c = ord(s)
+    except TypeError:
+        return 0
+    return 32 <= c < 128 and is_keyword_char(c)
+
+
+class PARIKernel(Kernel):
+    implementation = 'PARI'
+    implementation_version = PARIKernel.__version__
+    language = 'GP'
+    language_version = pari_short_version()
+    language_info = dict(mimetype='text/x-pari-gp', name='gp', file_extension='.gp')
+    banner = "PARI/GP kernel"
+
+    def __init__(self, *args, **kwds):
+        super().__init__(*args, **kwds)
+
+        pari_init_opts(PARISIZE, PRIMELIMIT, INIT_SIGm | INIT_DFTm)
+        global cb_pari_err_recover
+        cb_pari_err_recover = pari_recover
+        self.io = PARIKernelIO(self)
+        pari_use_readline(pari_rl)
+        init_svg(self)
+
+    def do_execute(self, code, silent, store_history=True, user_expressions=None,
+                   allow_stdin=False):
+        global avma
+        cdef pari_sp av = avma
+        cdef GEN result
+
+        code = (<unicode?>code).encode("utf-8")
+        cdef const char* gp_code = <bytes>code
+
+        self.io.set_parent(self._parent_header)
+
+        cdef sigaction_t sa
+        cdef sigaction_t old_sa
+        memset(&sa, 0, sizeof(sa))
+        sa.sa_handler = pari_sighandler
+
+        cdef int err
+        cdef long t_ms, wt_ms
+        cdef char last
+
+        with nogil:
+            err = sigsetjmp(context, 1)
+            if err == 0:  # Initial sigsetjmp() call
+                sigaction(SIGINT, &sa, &old_sa)  # Handle SIGINT by PARI
+                timer_start(GP_DATA.T)
+                walltimer_start(GP_DATA.Tw)
+                result = gp_read_str_multiline(gp_code, &last)
+                t_ms = timer_delay(GP_DATA.T)
+                wt_ms = walltimer_delay(GP_DATA.Tw)
+            sigaction(SIGINT, &old_sa, &sa)      # Restore Python SIGINT handler
+
+        if err == 0:  # success
+            if not silent:
+                if t_ms and GP_DATA.chrono:
+                    pari_puts(b"time = ")
+                    pari_puts(gp_format_time(t_ms))
+                    pari_flush()
+
+            # gnil as a result is like Python's None, it should be
+            # considered as "no result"
+            if result is not gnil:
+                if store_history:
+                    pari_add_hist(result, t_ms, wt_ms)
+
+                if last != c';' and not silent:
+                    content = {
+                        'execution_count': pari_nb_hist(),
+                        'data': {
+                            'text/plain': PyUnicode_FromGEN(result),
+                        },
+                        'metadata': {}
+                    }
+                    self.send_response(self.iopub_socket, 'execute_result', content)
+
+            reply = {'status': 'ok',
+                     'execution_count': pari_nb_hist(),
+                     'payload': [],
+                     'user_expressions': {},
+                    }
+
+            avma = av
+
+        else:  # error (therefore no result)
+            reply = {'status': 'error',
+                     'execution_count': pari_nb_hist(),
+                     'ename': "",
+                     'evalue': "",
+                     'traceback': [],
+                    }
+
+            if err > 0:
+                # true error
+                avma = av
+            else:
+                # allocatemem
+                avma = pari_mainstack.top
+
+        self.io.flush()
+        return reply
+
+    def do_complete(self, code, cursor_pos):
+        cdef long word
+        cdef char** m = pari_completion_matches(&pari_rl,
+                (<unicode?>code).encode("utf-8"), cursor_pos, &word)
+
+        cdef list matches = []
+        if m != NULL:
+            if m[1] == NULL:  # Unique match
+                matches = [PyUnicode_FromString(m[0])]
+            else:             # Non-unique match
+                while m[1] != NULL:
+                    matches.append(PyUnicode_FromString(m[1]))
+                    m += 1
+
+        reply = dict(status="ok", matches=sorted(matches),
+                cursor_start=word, cursor_end=cursor_pos)
+        return reply
+
+    def do_inspect(self, code, cursor_pos, detail_level=0):
+        word = self.__get_keyword(code, cursor_pos)[0]
+        # Possibly rewind if we are right after a "("
+        if not word and cursor_pos > 0 and code[cursor_pos-1] == u"(":
+            word = self.__get_keyword(code, cursor_pos-1)[0]
+
+        reply = dict(status="ok", found=False, data={}, metadata={})
+        if not word:
+            return reply
+
+        cdef entree* ep = is_entry((<unicode?>word).encode("utf-8"))
+        if ep == NULL or ep.help == NULL:
+            return reply
+
+        reply["found"] = True
+        reply["data"] = {"text/plain": PyUnicode_FromString(ep.help)}
+        return reply
+
+    def publish_svg(self, svg, width, height):
+        # For some reason, the payload must be str, not bytes
+        if not isinstance(svg, str):
+            svg = PyUnicode_FromString(svg)
+        content = {
+            'data': {
+                "text/plain": "SVG plot",
+                "image/svg+xml": svg,
+            },
+            'metadata': {
+                "width": width,
+                "height": height,
+            }
+        }
+        self.send_response(self.iopub_socket, 'display_data', content)
+
+    def __get_keyword(self, code, pos):
+        """
+        Return a tuple ``(word, start, end)`` such that ``word`` is a
+        PARI "keyword" and ``word = code[start:end]``. The bounds are
+        such that ``start <= pos <= end``.
+        """
+        cdef Py_ssize_t start, end, length = len(code)
+        start = end = pos
+        while start > 0 and is_keyword_char_python(code[start-1]):
+            start -= 1
+        while end < length and is_keyword_char_python(code[end]):
+            end += 1
+        word = code[start:end]
+        return (word, start, end)

PARIKernel/paridecl.pxd

@@ -0,0 +1,95 @@
+# sage_setup: distribution = sagemath-pari
+# distutils: libraries = pari
+
+cdef extern from "pari/pari.h" nogil:
+    ctypedef unsigned long ulong "pari_ulong"
+    ctypedef long* GEN
+    ctypedef unsigned long pari_sp
+    ctypedef long pari_timer
+
+    ctypedef struct entree:
+        entree* next
+        char* name
+        const char* help
+
+    long    paricfg_version_code
+    long    PARI_VERSION_SHIFT
+
+    ctypedef struct pari_mainstack:
+        pari_sp top
+
+    pari_sp avma
+    pari_mainstack * pari_mainstack
+    GEN     gnil
+
+    int     INIT_JMPm, INIT_SIGm, INIT_DFTm, INIT_noPRIMEm, INIT_noIMTm
+    void    pari_init_opts(size_t parisize, ulong maxprime, ulong init_opts)
+    void    pari_init(size_t parisize, ulong maxprime)
+    void    pari_sighandler(int sig)
+
+    void    (*cb_pari_err_recover)(long)
+
+    void    pari_free(void*)
+
+    GEN     gp_read_str_multiline(const char *t, char *last)
+    char*   GENtostr(GEN x)
+    void    pari_add_hist(GEN z, long t, long r)
+    long    pari_nb_hist()
+
+    long    timer_delay(pari_timer *T)
+    long    timer_get(pari_timer *T)
+    void    timer_start(pari_timer *T)
+
+    long    walltimer_start(pari_timer *T)
+    long    walltimer_delay(pari_timer *T)
+
+    char*   gp_format_time(long delay)
+
+    void    pari_puts(char*)
+    void    pari_flush()
+
+    struct PariOUT:
+        void (*putch)(char)
+        void (*puts)(const char*)
+        void (*flush)()
+    PariOUT* pariOut
+    PariOUT* pariErr
+
+    entree* is_entry(char *s)
+
+    ctypedef struct PARI_plot:
+        long width
+        long height
+        long hunit
+        long vunit
+        long fwidth
+        long fheight
+        void (*draw)(PARI_plot *T, GEN w, GEN x, GEN y)
+
+    void pari_set_plot_engine(void (*T)(PARI_plot *))
+
+    char* rect2svg(GEN w, GEN x, GEN y, PARI_plot *T)
+
+
+cdef extern from "pari/paripriv.h" nogil:
+    long    is_keyword_char(char c)
+
+    ctypedef struct gp_data:
+        int chrono
+        pari_timer* T
+        pari_timer* Tw
+
+    gp_data* GP_DATA
+
+    ctypedef struct pari_rl_interface:
+        pass
+
+    void    pari_use_readline(pari_rl_interface)
+    char**  pari_completion_matches(pari_rl_interface*, char* s, long pos, long* wordpos)
+
+    void    init_graph()
+
+
+# It is important that this gets included *after* all PARI includes
+cdef extern from "parifix.h":
+    pass

PARIKernel/svg.pyx

@@ -0,0 +1,52 @@
+# sage_setup: distribution = sagemath-pari
+#cython: language_level=3
+#
+# Helper module to handle SVG images produced by PARI
+#
+# Copyright (C) 2017 Jeroen Demeyer
+#
+# 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 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+
+from .paridecl cimport *
+
+cdef pari_kernel
+
+
+def init_svg(kernel):
+    global pari_kernel
+    pari_kernel = kernel
+    pari_set_plot_engine(get_plot)
+
+
+cdef void get_plot(PARI_plot* T) noexcept nogil:
+    # Values copied from src/graph/plotsvg.c in PARI sources
+    T.width = 480
+    T.height = 320
+    T.hunit = 3
+    T.vunit = 3
+    T.fwidth = 9
+    T.fheight = 12
+
+    T.draw = draw
+
+
+cdef void draw(PARI_plot *T, GEN w, GEN x, GEN y) noexcept nogil:
+    global avma
+    cdef pari_sp av = avma
+    cdef char* svg = rect2svg(w, x, y, T)
+    with gil:
+        pari_kernel.publish_svg(svg, T.width, T.height)
+    avma = av

cypari2/__init__.py

@@ -0,0 +1,8 @@
+# sage_setup: distribution = sagemath-pari
+
+from .pari_instance import Pari
+from .handle_error import PariError
+from .gen import Gen
+from .custom_block import init_custom_block
+
+init_custom_block()