def __init__(self, shell=None):

# the embedded R process from rpy2

self.r = ro.R()

self.output = []

self.shell = shell

def eval(self, line):

# self.output.append(line + '\n')

try:

ri.baseenv['eval'](ri.parse(line))

except ri.RRuntimeError as msg:

self.output.append('ERROR parsing "%s": %s\n' % (line, msg))

pass

def write_console(self, output):

'''

A hook to capture R's stdout.

'''

self.output.append(output)

def flush(self):

value = ''.join(self.output)

self.output = []

return value

def push_line_magic(self, args):

'''

A line-level magic for R that pushes

variables from python to rpy2.

Parameters

----------

args: inputs

A white space separated string of

names of objects in the python name space to be

assigned to objects of the same name in the

R name space.

'''

args = args.split(' ')

for input in args:

# need to have access the shell to assign these

# python variables to variables in R

# for now, this is a hack, with self.shell a dictionary

self.r.assign(input, self.shell[input])

def pull_line_magic(self, args):

'''

A line-level magic for R that pushes

variables from python to rpy2.

Parameters

----------

args: outputs

A white space separated string of

names of objects in the R name space to be

assigned to objects of the same name in the

python name space.

Notes

-----

Beware that R names can have '.' so this is not fool proof.

To avoid this, don't name your R objects with '.'s...

'''

args = args.split(' ')

for output in args:

# need to have access the shell

# for now, this is a hack, with self.shell a dictionary

self.shell[output] = np.asarray(self.r(output))

def cell_magic(self, args, text):

'''

A cell-level magic for R.

Parameters

----------

args: {inputs, outputs, width, height, units, pointsize, bg}

Optional long arguments recognized by the cell magic.

The first two relate to passing python objects

back and forth between rpy2 and python:

'--inputs' should be a comma separated list of

names of objects in the namespace of the shell;

'--outputs' are names of object in the R namespace

that are returned as arrays.

All other args are passed as arguments to

the png plotting device in R.

text: str

String of R code to be executed by rpy2.

Anything written to stdout of R is captured,

as are plots (in the form of .png files) that

are published via ipython's frontend

publishing system.

'''

# need to get the ipython instance for assigning

opts, args = getopt(args.strip().split(' '), None, ['inputs=',

'outputs=',

# these are options for png

'width=',

'height=',

'units=',

'pointsize=',

'bg='])

opts = dict(opts)

outputs = []

for option, value in opts.items():

if option == '--inputs':

# need to have access the shell to assign these

# python variables to variables in R

opts.pop('--inputs')

# with self.shell, we will assign the values to variables in the shell

# for now, this is a hack, with self.shell a dictionary

for input in value.split(','):

self.r.assign(input, self.shell[input])

if option == '--outputs':

outputs = value.split(',')

opts.pop('--outputs')

png_args = ','.join(['%s=%s' % (o[2:],v) for o, v in opts.items()])

# execute the R code in a temporary directory

tmpd = tempfile.mkdtemp()

self.r('png("%s/Rplots%%03d.png",%s)' % (tmpd, png_args))

lines = text.split('\n')

[self.eval(line) for line in lines]

#self.eval(ri.parse(text))

self.r('dev.off()')

# read out all the saved .png files

images = [file(imgfile).read() for imgfile in glob("%s/Rplots*png" % tmpd)]

# now publish the images

# mimicking IPython/zmq/pylab/backend_inline.py

fmt = 'png'

mimetypes = { 'png' : 'image/png', 'svg' : 'image/svg+xml' }

mime = mimetypes[fmt]

# publish the printed R objects, if any

publish_display_data('Rmagic.cell_magic', {'text/plain':self.flush()})

# 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 sln)

sys.stdout.flush(); sys.stderr.flush()

publish_display_data(

'Rmagic.cell_magic',

{mime : image}

)

value = {}

# try to turn every output into a numpy array

# this means that outputs are assumed to be castable

# as numpy arrays

for output in outputs:

# with self.shell, we will assign the values to variables in the shell

self.shell[output] = np.asarray(self.r(output))

# kill the temporary directory

def __init__(self):

self.shell = EmbeddedRShell()

def cell_magic(self, args, text):

'''

A cell-level magic for R that mimics R's console.

Parameters

----------

args: {width, height, units, pointsize, bg}

Optional long arguments recognized by the cell magic.

All args are passed as arguments to

the png plotting device in R.

text: str

String of R code to be executed by rpy2.

Anything written to stdout of R is captured,

as are plots (in the form of .png files) that

are published via ipython's frontend

publishing system.

'''

# need to get the ipython instance for assigning

opts, args = getopt(args.strip().split(' '), None, [# these are options for png

'width=',

'height=',

'units=',

'pointsize=',

'bg='])

png_args = ','.join(['%s=%s' % (o[2:],v) for o, v in opts])

# execute the R code in a temporary directory

tmpd = tempfile.mkdtemp()

# flush the output

self.shell.astext()

# set the plotting device and record an error, if any

# maybe will be used for an exception

self.shell.process('png("%s/Rplots%%03d.png",%s)' % (tmpd, png_args))

png_error = self.shell.astext()

# execute the code

self.shell.process(text)

text_result = self.shell.astext()

# turn off the png device

self.shell.process('dev.off()')

# read out all the saved .png files

images = [file(imgfile).read() for imgfile in glob("%s/Rplots*png" % tmpd)]

# now publish the images

# mimicking IPython/zmq/pylab/backend_inline.py

fmt = 'png'

mimetypes = { 'png' : 'image/png', 'svg' : 'image/svg+xml' }

mime = mimetypes[fmt]

# publish the printed R objects, if any

publish_display_data('Rshell.cell_magic', {'text/plain':text_result})

# 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 sln)

sys.stdout.flush(); sys.stderr.flush()

publish_display_data(

'Rshell.cell_magic',

{mime : image}

)

value = {}

# kill the temporary directory