passagemath-repl 10.4.62__py3-none-any.whl

sage/repl/display/pretty_print.py

@@ -0,0 +1,153 @@
+# sage_setup: distribution = sagemath-repl
+"""
+The Sage pretty printer
+
+Any transformation to a string goes through here. In other words, the
+:class:`~sage.repl.displayhook.formatter.SagePlainTextFormatter` is
+entirely implemented via :class:`SagePrettyPrinter`. Other formatters
+may or may not use :class:`SagePrettyPrinter` to generate text output.
+
+AUTHORS:
+
+- Bill Cauchois (2009): initial version
+- Jean-Baptiste Priez <jbp@kerios.fr> (2013): ASCII art
+- Volker Braun (2013): refactored into DisplayHookBase
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2014 Volker Braun <vbraun.name@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.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+
+from IPython.lib.pretty import PrettyPrinter
+
+from sage.repl.display.fancy_repr import (TallListRepr, PlainPythonRepr,
+                                          LargeMatrixHelpRepr,
+                                          SomeIPythonRepr)
+
+
+class SagePrettyPrinter(PrettyPrinter):
+
+    DEBUG = False
+
+    # These object representers will be tried, in this order, until
+    # one is found that is able to deal with the object.
+    pretty_repr = (
+        TallListRepr(),
+        LargeMatrixHelpRepr(),
+        SomeIPythonRepr(),
+        PlainPythonRepr(),
+    )
+
+    def toplevel(self):
+        r"""
+        Return whether we are currently at the top level.
+
+        OUTPUT:
+
+        boolean; whether we are currently pretty-printing an object at
+        the outermost level (``True``), or whether the object is
+        inside a container (``False``).
+
+        EXAMPLES::
+
+            sage: from sage.repl.display.pretty_print import SagePrettyPrinter
+            sage: from io import StringIO
+            sage: stream = StringIO()
+            sage: spp = SagePrettyPrinter(stream, 78, '\n')
+            sage: spp.toplevel()
+            True
+        """
+        return len(self.stack) <= 1   # only the object currently being represented
+
+    def __init__(self, output, max_width, newline, max_seq_length=None):
+        """
+        Pretty print Sage objects for the commandline.
+
+        INPUT:
+
+        See IPython documentation.
+
+        EXAMPLES::
+
+            sage: 123
+            123
+
+        IPython pretty printers::
+
+            sage: set({1, 2, 3})
+            {1, 2, 3}
+            sage: dict(zzz=123, aaa=99, xab=10)    # sorted by keys
+            {'aaa': 99, 'xab': 10, 'zzz': 123}
+
+        These are overridden in IPython in a way that we feel is somewhat
+        confusing, and we prefer to print them like plain Python which is
+        more informative. See :issue:`14466` ::
+
+            sage: 'this is a string'
+            'this is a string'
+            sage: type(123)
+            <class 'sage.rings.integer.Integer'>
+            sage: type
+            <... 'type'>
+            sage: import types
+            sage: type('name', (), {})
+            <class '__main__.name'>
+            sage: types.BuiltinFunctionType
+            <class 'builtin_function_or_method'>
+
+            sage: def foo(): pass
+            sage: foo
+            <function foo at 0x...>
+        """
+        super().__init__(output, max_width, newline,
+                         max_seq_length=max_seq_length)
+        self.stack = []
+
+    def pretty(self, obj):
+        r"""
+        Pretty print ``obj``.
+
+        This is the only method that outside code should invoke.
+
+        INPUT:
+
+        - ``obj`` -- anything
+
+        OUTPUT: string representation for object
+
+        EXAMPLES::
+
+            sage: from sage.repl.display.pretty_print import SagePrettyPrinter
+            sage: from io import StringIO
+            sage: stream = StringIO()
+            sage: SagePrettyPrinter(stream, 78, '\n').pretty([type, 123, 'foo'])
+            sage: stream.getvalue()
+            "[<... 'type'>,"
+        """
+        obj_id = id(obj)
+        cycle = obj_id in self.stack
+        self.stack.append(obj_id)
+        self.begin_group()
+        try:
+            ok = False
+            for representation in self.pretty_repr:
+                if self.DEBUG:
+                    print('Trying {0}'.format(representation))
+                ok = representation(obj, self, cycle)
+                if self.DEBUG:
+                    print('ok = {0}'.format(ok))
+                if ok not in [True, False]:
+                    raise RuntimeError('printer failed to return boolean')
+                if ok:
+                    break
+            if not ok:
+                raise RuntimeError('no printer registered for object')
+        finally:
+            self.end_group()
+            self.stack.pop()

sage/repl/display/util.py

@@ -0,0 +1,163 @@
+# sage_setup: distribution = sagemath-repl
+"""
+Utility functions for pretty-printing
+
+These utility functions are used in the implementations of ``_repr_``
+methods elsewhere.
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2014 Volker Braun <vbraun.name@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.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+
+class TallListFormatter:
+    """
+    Special representation for lists with tall entries (e.g. matrices).
+
+    .. automethod:: __call__
+    """
+
+    # This is used to wrap lines when printing "tall" lists.
+    MAX_COLUMN = 70
+
+    def _tall_list_row(self, running_lines, last_row=False):
+        """
+        Helper for :meth:`_check_tall_list_and_format`.
+
+        This helper function processes and outputs the contents of the
+        running_lines array.
+
+        TESTS::
+
+            sage: from sage.repl.display.util import format_list
+            sage: format_list._tall_list_row(['a   b', 'b  c', 'c'])
+            ['a           b', 'b        c', 'c,', '']
+        """
+        s = []
+        for i, line in enumerate(running_lines):
+            if i + 1 != len(running_lines):
+                sep, tail = '  ', ''
+            else:
+                # The commas go on the bottom line of this row.
+                sep, tail = ', ', '' if last_row else ','
+            s.append(sep.join(line) + tail)
+        # Separate rows with a newline to make them stand out.
+        if not last_row:
+            s.append("")
+        return s
+
+    def try_format(self, the_list):
+        """
+        First check whether a list is "tall" -- whether the reprs of the
+        elements of the list will span multiple lines and cause the list
+        to be printed awkwardly.  If not, this function returns ``None`` and
+        does nothing; you should revert back to the normal method for
+        printing an object (its repr). If so, return the string in the
+        special format. Note that the special format isn't just for
+        matrices. Any object with a multiline repr will be formatted.
+
+        INPUT:
+
+        - ``the_list`` -- the list (or a tuple)
+
+        OUTPUT:
+
+        String or ``None``. The latter is returned if the list is not
+        deemed to be tall enough and another formatter should be used.
+
+        TESTS::
+
+            sage: from sage.repl.display.util import format_list
+            sage: print(format_list.try_format(                                         # needs sage.modules
+            ....:        [matrix([[1, 2, 3, 4], [5, 6, 7, 8]]) for i in range(7)]))
+            [
+            [1 2 3 4]  [1 2 3 4]  [1 2 3 4]  [1 2 3 4]  [1 2 3 4]  [1 2 3 4]
+            [5 6 7 8], [5 6 7 8], [5 6 7 8], [5 6 7 8], [5 6 7 8], [5 6 7 8],
+            <BLANKLINE>
+            [1 2 3 4]
+            [5 6 7 8]
+            ]
+
+            sage: format_list.try_format(['not', 'tall']) is None
+            True
+        """
+        # For every object to be printed, split its repr on newlines and store the
+        # result in this list.
+        split_reprs = []
+        tall = False
+        for elem in the_list:
+            split_reprs.append(repr(elem).split('\n'))
+            if len(split_reprs[-1]) > 1:
+                # Meanwhile, check to make sure the list is actually "tall".
+                tall = True
+        if not tall:
+            return None
+        # Figure out which type of parenthesis to use, based on the type of the_list.
+        if isinstance(the_list, tuple):
+            parens = '()'
+        elif isinstance(the_list, list):
+            parens = '[]'
+        else:
+            raise TypeError('expected list or tuple')
+
+        # running_lines is a list of lines, which are stored as lists of strings
+        # to be joined later. For each split repr, we add its lines to the
+        # running_lines array. When current_column exceeds MAX_COLUMN, process
+        # and output running_lines using _print_tall_list_row.
+        running_lines = [[]]
+        current_column = 0
+        s = [parens[0]]
+        for split_repr in split_reprs:
+            width = max(len(x) for x in split_repr)
+            if current_column + width > self.MAX_COLUMN and not (width > self.MAX_COLUMN):
+                s.extend(self._tall_list_row(running_lines))
+                running_lines = [[]]
+                current_column = 0
+            current_column += width + 2
+            # Add the lines from split_repr to the running_lines array. It may
+            # be necessary to add or remove lines from either one so that the
+            # number of lines matches up.
+            for i in range(len(running_lines), len(split_repr)):
+                running_lines.insert(0, [' ' * len(x) for x in running_lines[-1]])
+            line_diff = len(running_lines) - len(split_repr)
+            for i, x in enumerate(split_repr):
+                running_lines[i + line_diff].append(x.ljust(width))
+            for i in range(line_diff):
+                running_lines[i].append(' ' * width)
+        # Output any remaining entries.
+        if len(running_lines[0]) > 0:
+            s.extend(self._tall_list_row(running_lines, True))
+        s.append(parens[1])
+        return "\n".join(s)
+
+    def __call__(self, the_list):
+        """
+        Return "tall list" string representation.
+
+        See also :meth:`try_format`.
+
+        INPUT:
+
+        - ``the_list`` -- list or tuple
+
+        OUTPUT: string
+
+        EXAMPLES::
+
+            sage: from sage.repl.display.util import format_list
+            sage: format_list(['not', 'tall'])
+            "['not', 'tall']"
+        """
+        output = self.try_format(the_list)
+        if output is None:
+            output = repr(the_list)
+        return output
+
+
+format_list = TallListFormatter()

sage/repl/image.py

@@ -0,0 +1,302 @@
+# sage_setup: distribution = sagemath-repl
+# sage.doctest: needs pillow
+"""
+Sage Wrapper for Bitmap Images
+
+Some computations in Sage return bitmap images, for example matrices
+can be turned into bitmaps directly. Note that this is different from
+all plotting functionality, the latter can equally produce vector
+graphics. This module is about bitmaps only, and a shallow wrapper
+around ``PIL.Image``. The only difference is that :class:`Image`
+is displayed as graphics by the Sage if the UI can.
+
+EXAMPLES::
+
+    sage: from sage.repl.image import Image
+    sage: img = Image('RGB', (256, 256), 'white')
+    sage: pixels = img.pixels()
+    sage: for x in range(img.width()):
+    ....:     for y in range(img.height()):
+    ....:         pixels[x, y] = (x, y, 100)
+    sage: img
+    256x256px 24-bit RGB image
+    sage: type(img)
+    <class 'sage.repl.image.Image'>
+"""
+
+# ****************************************************************************
+#       Copyright (C) 2015 Volker Braun <vbraun.name@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.
+#                  https://www.gnu.org/licenses/
+# ****************************************************************************
+
+import io
+
+import PIL.Image
+from sage.structure.sage_object import SageObject
+
+
+class Image(SageObject):
+
+    def __init__(self, mode, size, color='white'):
+        """
+        Create a new image with the given mode and size.
+
+        INPUT:
+
+        - ``mode`` -- string. The mode to use for the new image. Valid
+          options are:
+
+              * ``'1'`` (1-bit pixels, black and white, stored with
+                one pixel per byte)
+
+              * ``'L'`` (8-bit pixels, black and white)
+
+              * ``'P'`` (8-bit pixels, mapped to any other mode using
+                a color palette)
+
+              * ``'RGB'`` (3x8-bit pixels, true color)
+
+              * ``'RGBA'`` (4x8-bit pixels, true color with
+                transparency mask)
+
+              * ``'CMYK'`` (4x8-bit pixels, color separation)
+
+              * ``'YCbCr'`` (3x8-bit pixels, color video format)
+
+              * ``'LAB'`` (3x8-bit pixels, the L*a*b color space)
+
+              * ``'HSV'`` (3x8-bit pixels, Hue, Saturation, Value
+                color space)
+
+              * ``'I'`` (32-bit signed integer pixels)
+
+              * ``'F'`` (32-bit floating point pixels)
+
+        - ``size`` -- 2-tuple, containing (width, height) in pixels
+
+        - ``color`` -- string, numeric or tuple of numeric. What colour to use
+          for the image. Default is black.  If given, this should be a
+          a tuple with one value per band. When creating RGB images,
+          you can also use colour strings as supported by the
+          ImageColor module.  If the colour is None, the image is not
+          initialised.
+
+        OUTPUT: a new :class:`Image` object
+
+        EXAMPLES::
+
+            sage: from sage.repl.image import Image
+            sage: Image('P', (16, 16), 13)
+            16x16px 8-bit Color image
+        """
+        # pillow does not support Sage integers as color
+        from sage.rings.integer import Integer
+        if isinstance(color, Integer):
+            color = int(color)
+        elif isinstance(color, tuple):
+            color = tuple(int(i) if isinstance(i, Integer) else i for i in color)
+        self._pil = PIL.Image.new(mode, size, color)
+
+    @property
+    def pil(self):
+        """
+        Access the wrapped PIL(low) Image.
+
+        OUTPUT: the underlying ``PIL.Image.Image object``
+
+        EXAMPLES::
+
+            sage: from sage.repl.image import Image
+            sage: img = Image('RGB', (16, 16), 'white')
+            sage: img.pil
+            <PIL.Image.Image image mode=RGB size=16x16 at 0x...>
+        """
+        return self._pil
+
+    def pixels(self):
+        """
+        Return the pixel map.
+
+        OUTPUT:
+
+        The PIL PixelAccess object that allows you to get/set the
+        pixel data.
+
+        EXAMPLES::
+
+            sage: from sage.repl.image import Image
+            sage: img = Image('RGB', (16, 16), 'white')
+            sage: img.pixels()
+            <PixelAccess object at 0x...>
+        """
+        return self._pil.load()
+
+    def _repr_(self) -> str:
+        """
+        Return string representation.
+
+        OUTPUT: string
+
+        EXAMPLES::
+
+            sage: from sage.repl.image import Image
+            sage: Image('RGB', (16, 16), 'white')   # indirect doctest
+            16x16px 24-bit RGB image
+        """
+        modestr = {
+            '1': '{0}x{1}px BW image',
+            'L': '{0}x{1}px 8-bit BW image',
+            'P': '{0}x{1}px 8-bit Color image',
+            'RGB': '{0}x{1}px 24-bit RGB image',
+            'RGBA': '{0}x{1}px 32-bit RGBA image',
+            'CMYK': '{0}x{1}px 24-bit CMYK image',
+            'YCbCr': '{0}x{1}px 24-bit YCbCr mage',
+            'LAB': '{0}x{1}px 24-bit LAB image',
+            'HSV': '{0}x{1}px 24-bit HSV image',
+            'I': '{0}x{1}px 32-bit signed integer image',
+            'F': '{0}x{1}px 32-bit float image',
+        }
+        try:
+            mode = modestr[self.pil.mode]
+        except AttributeError:
+            mode = 'Unknown mode'
+        width, height = self.pil.size
+        return mode.format(width, height)
+
+    def mode(self):
+        """
+        Return the color mode.
+
+        OUTPUT: string; as given when constructing the image
+
+        EXAMPLES::
+
+            sage: from sage.repl.image import Image
+            sage: img = Image('YCbCr', (16, 16), 'white')
+            sage: img.mode()
+            'YCbCr'
+        """
+        return self.pil.mode
+
+    def width(self):
+        """
+        Return the horizontal dimension in pixels.
+
+        OUTPUT: integer
+
+        EXAMPLES::
+
+            sage: from sage.repl.image import Image
+            sage: img = Image('1', (12, 34), 'white')
+            sage: img.width()
+            12
+            sage: img.height()
+            34
+        """
+        return self.pil.size[0]
+
+    def height(self):
+        """
+        Return the vertical dimension in pixels.
+
+        OUTPUT: integer
+
+        EXAMPLES::
+
+            sage: from sage.repl.image import Image
+            sage: img = Image('1', (12, 34), 'white')
+            sage: img.width()
+            12
+            sage: img.height()
+            34
+        """
+        return self.pil.size[1]
+
+    def save(self, filename):
+        r"""
+        Save the bitmap image.
+
+        INPUT:
+
+        - ``filename`` -- string; the filename to save as. The given
+          extension automatically determines the image file type
+
+        EXAMPLES::
+
+            sage: from sage.repl.image import Image
+            sage: img = Image('P', (12, 34), 13)
+            sage: filename = tmp_filename(ext='.png')
+            sage: img.save(filename)
+            sage: with open(filename, 'rb') as f:
+            ....:     f.read(4) == b'\x89PNG'
+            True
+        """
+        self.pil.save(filename)
+
+    def show(self):
+        r"""
+        Show this image immediately.
+
+        This method attempts to display the graphics immediately,
+        without waiting for the currently running code (if any) to
+        return to the command line. Be careful, calling it from within
+        a loop will potentially launch a large number of external
+        viewer programs.
+
+        OUTPUT:
+
+        This method does not return anything. Use :meth:`save` if you
+        want to save the figure as an image.
+
+        EXAMPLES::
+
+            sage: from sage.repl.image import Image
+            sage: img = Image('1', (12, 34), 'white')
+            sage: img.show()
+        """
+        from sage.repl.rich_output import get_display_manager
+        dm = get_display_manager()
+        dm.display_immediately(self)
+
+    def _rich_repr_(self, display_manager, **kwds):
+        """
+        Rich Output Magic Method.
+
+        See :mod:`sage.repl.rich_output` for details.
+
+        EXAMPLES::
+
+            sage: from sage.repl.image import Image
+            sage: img = Image('1', (16, 16), 'white')
+            sage: from sage.repl.rich_output import get_display_manager
+            sage: dm = get_display_manager()
+            sage: img._rich_repr_(dm)
+            OutputImagePng container
+
+            sage: img = Image('F', (16, 16), 'white')   # not supported in PNG
+            sage: img._rich_repr_(dm)
+            OutputImageGif container
+        """
+        if display_manager.preferences.graphics == 'disable':
+            return
+        types = display_manager.types
+        preferred = (
+            ('PNG', types.OutputImagePng),
+            ('JPEG', types.OutputImageJpg),
+            ('GIF', types.OutputImageGif),
+        )
+        from sage.repl.rich_output.buffer import OutputBuffer
+        for format, output_container in preferred:
+            if output_container in display_manager.supported_output():
+                stream = io.BytesIO()
+                try:
+                    self.pil.save(stream, format=format)
+                except OSError:
+                    # not all formats support all modes, e.g. no alpha support in gif
+                    continue
+                buf = OutputBuffer(stream.getvalue())
+                return output_container(buf)

sage/repl/inputhook.py

@@ -0,0 +1,91 @@
+# sage_setup: distribution = sagemath-repl
+"""
+The Sage Input Hook
+
+This lets us perform actions while IPython is sitting at the terminal input
+prompt. We use it to reload attached files if they have changed.
+"""
+
+###########################################################################
+#       Copyright (C) 2016 Volker Braun <vbraun.name@gmail.com>
+#
+# 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/
+###########################################################################
+
+import select
+import errno
+import contextlib
+import io
+
+from IPython.core.getipython import get_ipython
+from IPython.terminal.pt_inputhooks import register
+
+import sage.repl.attach
+
+
+TIMEOUT = 0.25   # seconds
+
+
+def sage_inputhook(context):
+    f = context.fileno()
+    while True:
+        sage.repl.attach.reload_attached_files_if_modified()
+        try:
+            r, _, _ = select.select([f], [], [], TIMEOUT)
+            if f in r:
+                return  # IPython signalled us to stop
+        except OSError as e:
+            if e[0] != errno.EINTR:
+                raise
+
+
+register('sage', sage_inputhook)
+
+
+def install():
+    """
+    Install the Sage input hook.
+
+    EXAMPLES:
+
+    Make sure ipython is running so we really test this function::
+
+        sage: from sage.repl.interpreter import get_test_shell
+        sage: get_test_shell()
+        <sage.repl.interpreter.SageTestShell object at ...>
+
+    Run the function twice, to check it is idempotent (see :issue:`35235`)::
+
+        sage: from sage.repl.inputhook import install
+        sage: install()
+        sage: install()
+    """
+    ip = get_ipython()
+    if not ip:
+        return   # Not running in ipython, e.g. doctests
+    if ip._inputhook != sage_inputhook:
+        # silence `ip.enable_gui()` useless output
+        with contextlib.redirect_stdout(io.StringIO()):
+            ip.enable_gui('sage')
+
+
+def uninstall():
+    """
+    Uninstall the Sage input hook.
+
+    EXAMPLES::
+
+        sage: from sage.repl.inputhook import uninstall
+        sage: uninstall()
+    """
+    ip = get_ipython()
+    if not ip:
+        return
+    if ip._inputhook == sage_inputhook:
+        # silence `ip.enable_gui()` useless output
+        with contextlib.redirect_stdout(io.StringIO()):
+            ip.enable_gui(None)