import sys

import re

import os.path

import uuid

from IPython.display import Image, SVG

from metakernel import MetaKernel, ProcessMetaKernel, pexpect, u

from metakernel.process_metakernel import TextOutput

from .replwrap import GnuplotREPLWrapper, PROMPT

from .exceptions import GnuplotError

# This is the only place that the version is

# specified

__version__ = '0.3.0'

# name of the command i.e first token

CMD_RE = re.compile(r'^\s*(\w+)\s?')

# "set multiplot" and abbreviated variants

MULTI_RE = re.compile(r'\s*set\s+multip(?:l|lo|lot)?')

# "unset multiplot" and abbreviated variants

UNMULTI_RE = re.compile(r'\s*uns(?:e|et)?\s+multip(?:l|lo|lot)?')

PLOT_CMDS = {

'plot', 'plo', 'pl', 'p',

'splot', 'splo', 'spl', 'sp',

'replot', 'replo', 'repl', 'rep',

}

# "set output" and abbreviated variants

SET_OUTPUT_RE = re.compile(

r'\s*set\s+o(?:u|ut|utp|utpu|utput)?(?:\s+|$)'

)

# "unset output" and abbreviated variants

UNSET_OUTPUT_RE = re.compile(

r'\s*uns(?:e|et)?\s+o(?:u|ut|utp|utpu|utput)?\s*'

)

# funtions to recognise gnuplot statements that determine

# how we add temporary files for the images shown by jupyter

def is_set_output(stmt):

"""

Return True if stmt is a 'set output' statement

"""

m = re.match(SET_OUTPUT_RE, stmt)

return True if m else False

def is_unset_output(stmt):

"""

Return True if stmt is an 'unset output' statement

"""

m = re.match(UNSET_OUTPUT_RE, stmt)

return True if m else False

def is_set_multiplot(stmt):

"""

Return True if stmt is a plot statement

"""

m = re.match(MULTI_RE, stmt)

return True if m else False

def is_unset_multiplot(stmt):

"""

Return True if stmt is a plot statement

"""

m = re.match(UNMULTI_RE, stmt)

return True if m else False

def is_plot(stmt):

"""

Return True if stmt is a plot statement

"""

m = re.match(CMD_RE, stmt)

if m:

return m.group(1) in PLOT_CMDS

return False

class GnuplotKernel(ProcessMetaKernel):

implementation = 'Gnuplot Kernel'

implementation_version = __version__

language = 'gnuplot'

language_version = '5.0'

banner = 'Gnuplot Kernel'

language_info = {

'mimetype': 'text/x-gnuplot',

'name': 'gnuplot',

'file_extension': '.gp',

'codemirror_mode': 'Octave',

'help_links': MetaKernel.help_links,

}

kernel_json = {

'argv': [sys.executable,

'-m', 'gnuplot_kernel',

'-f', '{connection_file}'],

'display_name': 'gnuplot',

'language': 'gnuplot',

'name': 'gnuplot',

}

inline_plotting = True

reset_code = ''

_first = True

_image_files = []

_error = False

def bad_prompt_warning(self):

"""

Print warning if the prompt is not 'gnuplot>'

"""

if not self.wrapper.prompt.startswith('gnuplot>'):

msg = ("Warning: The prompt is currently set "

"to '{}'".format(self.wrapper.prompt))

print(msg)

def do_execute_direct(self, code):

# We wrap the real function so that gnuplot_kernel can

# give a message when an exception occurs. Without

# this, an exception happens silently

try:

return self._do_execute_direct(code)

except Exception as err:

print(f"Error: {err}")

raise err

def _do_execute_direct(self, code):

"""

Execute gnuplot code

"""

if self._first:

self._first = False

self.handle_plot_settings()

if self.inline_plotting:

code = self.add_inline_image_statements(code)

success = True

try:

result = super(GnuplotKernel,

self).do_execute_direct(code, silent=True)

except GnuplotError as e:

result = TextOutput(e.message)

success = False

if self.reset_code:

super(GnuplotKernel, self).do_execute_direct(

self.reset_code, silent=True)

if self.inline_plotting:

if success:

self.display_images()

self.delete_image_files()

self.bad_prompt_warning()

# No empty strings

return result if (result and result.output) else None

def add_inline_image_statements(self, code):

"""

Add 'set output ...' before every plotting statement

This is what powers inline plotting

"""

# Ensure that there are no stale images

self.delete_image_files()

def set_output_inline(lines):

filename = self.get_image_filename()

if filename:

lines.append("set output '{}'".format(filename))

# We automatically create an output file for the following

# cases if the user has not created one.

# - before every every plot statement that is not

# inside a multiplot block

# - before every multiplot block

lines = []

sm = StateMachine()

is_joined_stmt = False

for stmt in code.splitlines():

sm.transition(stmt)

add_inline_plot = (

sm.prev_cur in (

('none', 'plot'),

('none', 'multiplot'),

('plot', 'plot')

)

and not is_joined_stmt

)

if add_inline_plot:

set_output_inline(lines)

lines.append(stmt)

is_joined_stmt = stmt.strip().endswith('\\')

# Make gnuplot flush the output

if not lines[-1].endswith('\\'):

lines.append('unset output')

code = '\n'.join(lines)

return code

def get_image_filename(self):

"""

Create file to which gnuplot will write the plot

Returns the filename.

"""

# we could use tempfile.NamedTemporaryFile but we do not

# want to create the file, gnuplot will create it.

# Later on when we check if the file exists we know

# whodunnit.

settings = self.plot_settings

filename = '/tmp/gnuplot-inline-{}.{}'.format(

uuid.uuid1(),

settings['format'])

filename = filename

self._image_files.append(filename)

return filename

def display_images(self):

"""

Display images if gnuplot wrote to them

"""

settings = self.plot_settings

if self.inline_plotting:

if settings['format'] == 'svg':

_Image = SVG

else:

_Image = Image

for filename in self._image_files:

try:

size = os.path.getsize(filename)

except FileNotFoundError:

size = 0

if not size:

msg = (

"Failed to read and display image file from gnuplot."

"May be you have plotted to a non interactive terminal."

)

print(msg)

continue

im = _Image(filename)

self.Display(im)

def delete_image_files(self):

"""

Delete the image files

"""

# After display_images(), the real images are

# no longer required.

for filename in self._image_files:

try:

os.remove(filename)

except FileNotFoundError:

pass

self._image_files = []

def makeWrapper(self):

"""

Start gnuplot and return wrapper around the REPL

"""

if pexpect.which('gnuplot'):

program = 'gnuplot'

elif pexpect.which('gnuplot.exe'):

program = 'gnuplot.exe'

else:

raise Exception("gnuplot not found.")

# We don't want help commands getting stuck,

# use a non interactive PAGER

if pexpect.which('env') and pexpect.which('cat'):

command = 'env PAGER=cat {}'.format(program)

else:

command = program

d = dict(cmd_or_spawn=command,

prompt_regex=u('\w*> $'),

prompt_change_cmd=None)

wrapper = GnuplotREPLWrapper(**d)

# No sleeping before sending commands to gnuplot

wrapper.child.delaybeforesend = 0

return wrapper

def do_shutdown(self, restart):

"""

Exit the gnuplot process and any other underlying stuff

"""

self.wrapper.exit()

super(GnuplotKernel, self).do_shutdown(restart)

def get_kernel_help_on(self, info, level=0, none_on_fail=False):

obj = info.get('help_obj', '')

if not obj or len(obj.split()) > 1:

if none_on_fail:

return None

else:

return ''

res = self.do_execute_direct('help %s' % obj)

text = res.output.strip().rstrip(PROMPT)

self.bad_prompt_warning()

return text

def handle_plot_settings(self):

"""

Handle the current plot settings

This is used by the gnuplot line magic. The plot magic

is innadequate.

"""

settings = self.plot_settings

if ('termspec' not in settings or

not settings['termspec']):

settings['termspec'] = ('pngcairo size 385, 256'

' font "Arial,10"')

if ('format' not in settings or

not settings['format']):

settings['format'] = 'png'

self.inline_plotting = settings['backend'] == 'inline'

cmd = 'set terminal {}'.format(settings['termspec'])

self.do_execute_direct(cmd)

class StateMachine:

"""

Track context given gnuplot statements

This is used to help us tell when to add inline commands

so that gnuplot can create inline images for the notebook

"""

states = ['none', 'plot', 'output', 'multiplot', 'output_multiplot']

previous = 'none'

_current = 'none'

@property

def prev_cur(self):

return (self.previous, self.current)

@property

def current(self):

return self._current

@current.setter

def current(self, value):

self.previous = self._current

self._current = value

def transition(self, stmt):

lookup = {

s: getattr(self, f'transition_from_{s}')

for s in self.states

}

_transition = lookup[self.current]

self.previous = self._current

return _transition(stmt)

def transition_from_plot(self, stmt):

if self.current == 'output':

self.current = 'none'

elif self.current == 'plot':

if is_plot(stmt):

self.current = 'plot'

elif is_set_output(stmt):

self.current = 'output'

else:

self.current = 'none'

def transition_from_none(self, stmt):

if is_plot(stmt):

self.current = 'plot'

elif is_set_output(stmt):

self.current = 'output'

elif is_set_multiplot(stmt):

self.current = 'multiplot'

def transition_from_output(self, stmt):

if is_plot(stmt):

self.current = 'plot'

elif is_set_multiplot(stmt):

self.current = 'output_multiplot'

elif is_unset_output(stmt):

self.current = 'none'

def transition_from_multiplot(self, stmt):

if is_unset_multiplot(stmt):

self.current = 'none'

def transition_from_output_multiplot(self, stmt):

if is_unset_multiplot(stmt):

self.previous = self.current

self.current = 'output'