Source code for rpy2.ipython.rmagic

# -*- coding: utf-8 -*-
"""
======
Rmagic
======

Magic command interface for interactive work with R in ipython. %R and %%R are
the line and cell magics, respectively.

.. note::

  You will need a working copy of R.

Usage
=====

To enable the magics below, execute `%load_ext rpy2.ipython`.

`%R`

{R_DOC}

`%Rpush`

{RPUSH_DOC}

`%Rpull`

{RPULL_DOC}

`%Rget`

{RGET_DOC}

"""

# -----------------------------------------------------------------------------
#  Copyright (C) 2012 The IPython Development Team
#  Copyright (C) 2013-2019 rpy2 authors
#
#  Distributed under the terms of the BSD License.  The full license is in
#  the file COPYING, distributed as part of this software.
# -----------------------------------------------------------------------------

import contextlib
import sys
import tempfile
from glob import glob
from os import stat
from shutil import rmtree
import textwrap

# numpy and rpy2 imports

import rpy2.rinterface as ri
import rpy2.rinterface_lib.callbacks
import rpy2.robjects as ro
import rpy2.robjects.packages as rpacks
from rpy2.robjects.lib import grdevices
from rpy2.robjects.conversion import (Converter,
                                      localconverter)
import warnings
from rpy2.robjects.conversion import converter as template_converter

# Try loading pandas and numpy, emitting a warning if either cannot be
# loaded.
try:
    import numpy
    try:
        import pandas
    except ImportError as ie:
        pandas = None
        warnings.warn('The Python package `pandas` is strongly '
                      'recommended when using `rpy2.ipython`. '
                      'Unfortunately it could not be loaded '
                      '(error: %s), '
                      'but at least we found `numpy`.' % str(ie))
except ImportError as ie:
    # Give up on numerics
    numpy = None
    warnings.warn('The Python package `pandas` is strongly '
                  'recommended when using `rpy2.ipython`. '
                  'Unfortunately it could not be loaded, '
                  'as we did not manage to load `numpy` '
                  'in the first place (error: %s).' % str(ie))

# IPython imports.

from IPython.core import displaypub
from IPython.core.magic import (Magics,
                                magics_class,
                                line_cell_magic,
                                line_magic,
                                needs_local_scope)
from IPython.core.magic_arguments import (argument,
                                          argument_group,
                                          magic_arguments,
                                          parse_argstring)


if numpy:
    from rpy2.robjects import numpy2ri
    template_converter += numpy2ri.converter
    if pandas:
        from rpy2.robjects import pandas2ri
        template_converter += pandas2ri.converter


def CELL_DISPLAY_DEFAULT(res, args):
    return ro.r.show(res)


[docs]class RInterpreterError(ri.embedded.RRuntimeError): """An error when running R code in a %%R magic cell.""" msg_prefix_template = ('Failed to parse and evaluate line %r.\n' 'R error message: %r') rstdout_prefix = '\nR stdout:\n' def __init__(self, line, err, stdout): self.line = line self.err = err.rstrip() self.stdout = stdout.rstrip() def __str__(self): s = (self.msg_prefix_template % (self.line, self.err)) if self.stdout and (self.stdout != self.err): s += self.rstdout_prefix + self.stdout return s
converter = Converter('ipython conversion', template=template_converter) # The default conversion for lists is currently to make them an R list. That # has some advantages, but can be inconvenient (and, it's inconsistent with # the way python lists are automatically converted by numpy functions), so # for interactive use in the rmagic, we call unlist, which converts lists to # vectors **if the list was of uniform (atomic) type**. @converter.rpy2py.register(list) def rpy2py_list(obj): # simplify2array is a utility function, but nice for us # TODO: use an early binding of the R function return ro.r.simplify2array(obj) # TODO: remove ? # # The R magic is opiniated about what the R vectors should become. # @converter.ri2ro.register(ri.SexpVector) # def _(obj): # if 'data.frame' in obj.rclass: # # request to turn it to a pandas DataFrame # res = converter.rpy2py(obj) # else: # res = ro.sexpvector_to_ro(obj) # return res
[docs]@magics_class class RMagics(Magics): """A set of magics useful for interactive work with R via rpy2. """ def __init__(self, shell, converter=converter, cache_display_data=False, device='png'): """ Parameters ---------- shell : IPython shell converter : rpy2 Converter instance to use. If None, the magic's current converter is used. cache_display_data : bool If True, the published results of the final call to R are cached in the variable 'display_cache'. device : ['png', 'X11', 'svg'] Device to be used for plotting. Currently only 'png', 'X11' and 'svg' are supported, with 'png' and 'svg' being most useful in the notebook, and 'X11' allowing interactive plots in the terminal. """ super(RMagics, self).__init__(shell) self.cache_display_data = cache_display_data self.Rstdout_cache = [] self.converter = converter self.set_R_plotting_device(device)
[docs] def set_R_plotting_device(self, device): """ Set which device R should use to produce plots. If device == 'svg' then the package 'Cairo' must be installed. Because Cairo forces "onefile=TRUE", it is not posible to include multiple plots per cell. Parameters ---------- device : ['png', 'X11', 'svg'] Device to be used for plotting. Currently only "png" and "X11" are supported, with 'png' and 'svg' being most useful in the notebook, and 'X11' allowing interactive plots in the terminal. """ device = device.strip() if device not in ['png', 'X11', 'svg']: raise ValueError( "device must be one of ['png', 'X11' 'svg'], got '%s'", device) if device == 'svg': try: self.cairo = rpacks.importr('Cairo') except ri.embedded.RRuntimeError as rre: if rpacks.isinstalled('Cairo'): msg = ('An error occurred when trying to load the ' + 'R package Cairo\'\n%s' % str(rre)) else: msg = textwrap.dedent(""" The R package 'Cairo' is required but it does not appear to be installed/available. Try: import rpy2.robjects.packages as rpacks utils = rpacks.importr('utils') utils.chooseCRANmirror(ind=1) utils.install_packages('Cairo') """) raise RInterpreterError(msg) self.device = device
[docs] @line_magic def Rdevice(self, line): """ Change the plotting device R uses to one of ['png', 'X11', 'svg']. """ self.set_R_plotting_device(line.strip())
[docs] def eval(self, code): """ Parse and evaluate a line of R code with rpy2. Returns the output to R's stdout() connection, the value generated by evaluating the code, and a boolean indicating whether the return value would be visible if the line of code were evaluated in an R REPL. R Code evaluation and visibility determination are done via an R call of the form withVisible(code_string), and this entire expression needs to be evaluated in R (we can't use rpy2 function proxies here, as withVisible is a LISPy R function). """ with contextlib.ExitStack() as stack: if self.cache_display_data: stack.enter( rpy2.rinterface_lib .callbacks.obj_in_module(rpy2.rinterface_lib.callbacks, 'consolewrite_print', self.write_console_regular) ) try: # Need the newline in case the last line in code is a comment. value, visible = ro.r("withVisible({%s\n})" % code) except (ri.embedded.RRuntimeError, ValueError) as exception: # Otherwise next return seems to have copy of error. warning_or_other_msg = self.flush() raise RInterpreterError(code, str(exception), warning_or_other_msg) text_output = self.flush() return text_output, value, visible[0]
[docs] def write_console_regular(self, output): """ A hook to capture R's stdout in a cache. """ self.Rstdout_cache.append(output)
[docs] def flush(self): """ Flush R's stdout cache to a string, returning the string. """ value = ''.join(self.Rstdout_cache) self.Rstdout_cache = [] return value
# @skip_doctest
[docs] @needs_local_scope @line_magic def Rpush(self, line, local_ns=None): """ A line-level magic for R that pushes variables from python to rpy2. The line should be made up of whitespace separated variable names in the IPython namespace:: In [7]: import numpy as np In [8]: X = np.array([4.5,6.3,7.9]) In [9]: X.mean() Out[9]: 6.2333333333333343 In [10]: %Rpush X In [11]: %R mean(X) Out[11]: array([ 6.23333333]) """ if local_ns is None: local_ns = {} inputs = line.split(' ') for input in inputs: try: val = local_ns[input] except KeyError: try: val = self.shell.user_ns[input] except KeyError: # reraise the KeyError as a NameError so that it looks like # the standard python behavior when you use an unnamed # variable raise NameError("name '%s' is not defined" % input) with localconverter(self.converter): ro.r.assign(input, val)
# @skip_doctest
[docs] @magic_arguments() @argument( 'outputs', nargs='*', ) @line_magic def Rpull(self, line): """ A line-level magic for R that pulls variables from python to rpy2:: In [18]: _ = %R x = c(3,4,6.7); y = c(4,6,7); z = c('a',3,4) In [19]: %Rpull x y z In [20]: x Out[20]: array([ 3. , 4. , 6.7]) In [21]: y Out[21]: array([ 4., 6., 7.]) In [22]: z Out[22]: array(['a', '3', '4'], dtype='|S1') This is useful when a structured array is desired as output, or when the object in R has mixed data types. See the %%R docstring for more examples. Notes ----- Beware that R names can have dots ('.') so this is not fool proof. To avoid this, don't name your R objects with dots... """ args = parse_argstring(self.Rpull, line) outputs = args.outputs with localconverter(self.converter): for output in outputs: robj = ri.globalenv.find(output) self.shell.push({output: robj})
# @skip_doctest
[docs] @magic_arguments() @argument( 'output', nargs=1, type=str, ) @line_magic def Rget(self, line): """ Return an object from rpy2, possibly as a structured array (if possible). Similar to Rpull except only one argument is accepted and the value is returned rather than pushed to self.shell.user_ns:: In [3]: dtype=[('x', '<i4'), ('y', '<f8'), ('z', '|S1')] In [4]: datapy = np.array([(1, 2.9, 'a'), (2, 3.5, 'b'), ... (3, 2.1, 'c'), (4, 5, 'e')], ... dtype=dtype) In [5]: %R -i datapy In [6]: %Rget datapy Out[6]: array([['1', '2', '3', '4'], ['2', '3', '2', '5'], ['a', 'b', 'c', 'e']], dtype='|S1') """ args = parse_argstring(self.Rget, line) output = args.output # get the R object with the given name, starting from globalenv # in the search path with localconverter(self.converter): res = ro.globalenv.find(output[0]) return res
[docs] def setup_graphics(self, args): """Setup graphics in preparation for evaluating R code. args : argparse bunch (should be whatever the R magic got).""" if getattr(args, 'units') is not None: if args.units != "px" and getattr(args, 'res') is None: args.res = 72 plot_arg_names = ['width', 'height', 'pointsize', 'bg', 'type'] if self.device == 'png': plot_arg_names += ['units', 'res'] argdict = {} for name in plot_arg_names: val = getattr(args, name) if val is not None: argdict[name] = val tmpd = None if self.device in ['png', 'svg']: # Create a temporary directory for R graphics output # TODO: Do we want to capture file output for other device types # other than svg & png? tmpd = tempfile.mkdtemp() tmpd_fix_slashes = tmpd.replace('\\', '/') if self.device == 'png': # Note: that %% is to pass into R for interpolation there grdevices.png("%s/Rplots%%03d.png" % tmpd_fix_slashes, **argdict) elif self.device == 'svg': self.cairo.CairoSVG("%s/Rplot.svg" % tmpd_fix_slashes, **argdict) elif self.device == 'X11': # Open a new X11 device, except if the current one is already an # X11 device. ro.r(""" if (substr(names(dev.cur()), 1, 3) != "X11") { X11() }""") else: # TODO: This isn't actually an R interpreter error... raise RInterpreterError( 'device must be one of ("png", "X11", "svg")') return tmpd
[docs] def publish_graphics(self, graph_dir, isolate_svgs=True): """Wrap graphic file data for presentation in IPython graph_dir : str Probably provided by some tmpdir call isolate_svgs : bool Enable SVG namespace isolation in metadata""" # read in all the saved image files images = [] display_data = [] # Default empty metadata dictionary. md = {} if self.device == 'png': for imgfile in sorted(glob('%s/Rplots*png' % graph_dir)): if stat(imgfile).st_size >= 1000: with open(imgfile, 'rb') as fh_img: images.append(fh_img.read()) else: # as onefile=TRUE, there is only one .svg file imgfile = "%s/Rplot.svg" % graph_dir # Cairo creates an SVG file every time R is called # -- empty ones are not published if stat(imgfile).st_size >= 1000: with open(imgfile, 'rb') as fh_img: images.append(fh_img.read().decode()) mimetypes = {'png': 'image/png', 'svg': 'image/svg+xml'} mime = mimetypes[self.device] # By default, isolate SVG images in the Notebook to avoid garbling. if images and self.device == "svg" and isolate_svgs: md = {'image/svg+xml': dict(isolated=True)} # Flush text streams before sending figures, helps a little with # output. for image in images: # Synchronization in the console (though it's a bandaid, not a # real solution). sys.stdout.flush() sys.stderr.flush() display_data.append(('RMagic.R', {mime: image})) return display_data, md
# @skip_doctest
[docs] @magic_arguments() @argument( '-i', '--input', action='append', help=textwrap.dedent(""" Names of input variable from `shell.user_ns` to be assigned to R variables of the same names after using the Converter self.converter. Multiple names can be passed separated only by commas with no whitespace.""") ) @argument( '-o', '--output', action='append', help=textwrap.dedent(""" Names of variables to be pushed from rpy2 to `shell.user_ns` after executing cell body (rpy2's internal facilities will apply ri2ro as appropriate). Multiple names can be passed separated only by commas with no whitespace.""") ) @argument( '-n', '--noreturn', help='Force the magic to not return anything.', action='store_true', default=False ) @argument_group("Plot", "Arguments to plotting device") @argument( '-w', '--width', type=float, help='Width of plotting device in R.' ) @argument( '-h', '--height', type=float, help='Height of plotting device in R.' ) @argument( '-p', '--pointsize', type=int, help='Pointsize of plotting device in R.' ) @argument( '-b', '--bg', help='Background of plotting device in R.' ) @argument_group("SVG", "SVG specific arguments") @argument( '--noisolation', help=textwrap.dedent(""" Disable SVG isolation in the Notebook. By default, SVGs are isolated to avoid namespace collisions between figures. Disabling SVG isolation allows to reference previous figures or share CSS rules across a set of SVGs."""), action='store_false', default=True, dest='isolate_svgs' ) @argument_group("PNG", "PNG specific arguments") @argument( '-u', '--units', type=str, choices=["px", "in", "cm", "mm"], help=textwrap.dedent(""" Units of png plotting device sent as an argument to *png* in R. One of ["px", "in", "cm", "mm"].""")) @argument( '-r', '--res', type=int, help=textwrap.dedent(""" Resolution of png plotting device sent as an argument to *png* in R. Defaults to 72 if *units* is one of ["in", "cm", "mm"].""") ) @argument( '--type', type=str, choices=['cairo', 'cairo-png', 'Xlib', 'quartz'], help=textwrap.dedent(""" Type device used to generate the figure. """)) @argument( '-c', '--converter', default=None, help=textwrap.dedent(""" Name of local converter to use. A converter contains the rules to convert objects back and forth between Python and R. If not specified/None, the defaut converter for the magic\'s module is used (that is rpy2\'s default converter + numpy converter + pandas converter if all three are available).""")) @argument( '-d', '--display', default=None, help=textwrap.dedent(""" Name of function to use to display the output of an R cell (the last object or function call that does not have a left-hand side assignment). That function will have the signature `(robject, args)` where `robject` is the R objects that is an output of the cell, and `args` a namespace with all parameters passed to the cell. """)) @argument( 'code', nargs='*', ) @needs_local_scope @line_cell_magic def R(self, line, cell=None, local_ns=None): """ Execute code in R, optionally returning results to the Python runtime. In line mode, this will evaluate an expression and convert the returned value to a Python object. The return value is determined by rpy2's behaviour of returning the result of evaluating the final expression. Multiple R expressions can be executed by joining them with semicolons:: In [9]: %R X=c(1,4,5,7); sd(X); mean(X) Out[9]: array([ 4.25]) In cell mode, this will run a block of R code. The resulting value is printed if it would be printed when evaluating the same code within a standard R REPL. Nothing is returned to python by default in cell mode:: In [10]: %%R ....: Y = c(2,4,3,9) ....: summary(lm(Y~X)) Call: lm(formula = Y ~ X) Residuals: 1 2 3 4 0.88 -0.24 -2.28 1.64 Coefficients: Estimate Std. Error t value Pr(>|t|) (Intercept) 0.0800 2.3000 0.035 0.975 X 1.0400 0.4822 2.157 0.164 Residual standard error: 2.088 on 2 degrees of freedom Multiple R-squared: 0.6993,Adjusted R-squared: 0.549 F-statistic: 4.651 on 1 and 2 DF, p-value: 0.1638 In the notebook, plots are published as the output of the cell:: %R plot(X, Y) will create a scatter plot of X bs Y. If cell is not None and line has some R code, it is prepended to the R code in cell. Objects can be passed back and forth between rpy2 and python via the -i -o flags in line:: In [14]: Z = np.array([1,4,5,10]) In [15]: %R -i Z mean(Z) Out[15]: array([ 5.]) In [16]: %R -o W W=Z*mean(Z) Out[16]: array([ 5., 20., 25., 50.]) In [17]: W Out[17]: array([ 5., 20., 25., 50.]) The return value is determined by these rules: * If the cell is not None (i.e., has contents), the magic returns None. * If the final line results in a NULL value when evaluated by rpy2, then None is returned. * No attempt is made to convert the final value to a structured array. Use %Rget to push a structured array. * If the -n flag is present, there is no return value. * A trailing ';' will also result in no return value as the last value in the line is an empty string. """ args = parse_argstring(self.R, line) # arguments 'code' in line are prepended to # the cell lines if cell is None: code = '' return_output = True line_mode = True else: code = cell return_output = False line_mode = False code = ' '.join(args.code) + code # if there is no local namespace then default to an empty dict if local_ns is None: local_ns = {} if args.converter is None: converter = self.converter else: try: converter = local_ns[args.converter] except KeyError: try: converter = self.shell.user_ns[args.converter] except KeyError: raise NameError( "name '%s' is not defined" % args.converter ) if not isinstance(converter, Converter): raise TypeError("'%s' must be a %s object (but it is a %s)." % (args.converter, Converter, type(localconverter))) if args.input: for input in ','.join(args.input).split(','): try: val = local_ns[input] except KeyError: try: val = self.shell.user_ns[input] except KeyError: raise NameError("name '%s' is not defined" % input) with localconverter(converter) as cv: ro.r.assign(input, val) if args.display: try: cell_display = local_ns[args.display] except KeyError: try: cell_display = self.shell.user_ns[args.display] except KeyError: raise NameError("name '%s' is not defined" % args.display) else: cell_display = CELL_DISPLAY_DEFAULT tmpd = self.setup_graphics(args) text_output = '' try: if line_mode: for line in code.split(';'): text_result, result, visible = self.eval(line) text_output += text_result if text_result: # The last line printed something to the console so # we won't return it. return_output = False else: text_result, result, visible = self.eval(code) text_output += text_result if visible: with contextlib.ExitStack() as stack: if self.cache_display_data: stack.enter_context( rpy2.rinterface_lib .callbacks .obj_in_module(rpy2.rinterface_lib .callbacks, 'consolewrite_print', self.write_console_regular)) cell_display(result, args) text_output += self.flush() except RInterpreterError as e: # TODO: Maybe we should make this red or something? print(e.stdout) if not e.stdout.endswith(e.err): print(e.err) if tmpd: rmtree(tmpd) return finally: if self.device in ['png', 'svg']: ro.r('dev.off()') if text_output: # display_data.append(('RMagic.R', {'text/plain':text_output})) displaypub.publish_display_data( data={'text/plain': text_output}, source='RMagic.R') # publish the R images if self.device in ['png', 'svg']: display_data, md = self.publish_graphics(tmpd, args.isolate_svgs) for tag, disp_d in display_data: displaypub.publish_display_data(data=disp_d, source=tag, metadata=md) # kill the temporary directory - currently created only for "svg" # and "png" (else it's None) rmtree(tmpd) if args.output: with localconverter(converter) as cv: for output in ','.join(args.output).split(','): output_ipy = ro.globalenv.find(output) self.shell.push({output: output_ipy}) # this will keep a reference to the display_data # which might be useful to other objects who happen to use # this method if self.cache_display_data: self.display_cache = display_data # We're in line mode and return_output is still True, # so return the converted result if return_output and not args.noreturn: if result is not ri.NULL: with localconverter(converter) as cv: res = cv.rpy2py(result) return res
__doc__ = __doc__.format( R_DOC=' '*8 + RMagics.R.__doc__, RPUSH_DOC=' '*8 + RMagics.Rpush.__doc__, RPULL_DOC=' '*8 + RMagics.Rpull.__doc__, RGET_DOC=' '*8 + RMagics.Rget.__doc__ )
[docs]def load_ipython_extension(ip): """Load the extension in IPython.""" ip.register_magics(RMagics)