kernel.py

'''Biocham kernel wrapper'''
from subprocess import check_output
from bisect import bisect_left
from signal import SIGINT
import re
from os import getenv
from decimal import Decimal

from ipykernel.ipkernel import IPythonKernel
from pexpect import replwrap, exceptions
from IPython.core.display import display
import ipywidgets as widgets
from traitlets import Float

from .images import extract_image_filenames, display_data_for_image
from .commands import commands


class BiochamKernel(IPythonKernel):
    '''kernel class wrapping the Biocham REPL'''
    implementation = 'Biocham'
    implementation_version = '0.1.0'
    language = 'biocham'
    language_info = {
        'name': 'biocham',
        'mimetype': 'text/plain',
        'file_extension': '.bc',
        'pygments_lexer': 'prolog',
        'codemirror_mode': 'biocham',
    }
    banner = check_output(['biocham', '--version']).decode('utf-8')
    language_version = banner.split()[1]
    help_links = [{
        'text': 'Biocham Manual',
        'url': 'http://lifeware.inria.fr/biocham4/doc/'
    }]
    shell = None
    command_sep = re.compile(r'\.\s+')
    timeout = Float(getenv('BIOCHAM_TIMEOUT', 120))

    # KernelBase actually increases the execution count but IPythonKernel
    # overrides this using self.shell.execution_count (which we don't have)
    @property
    def execution_count(self):
        return self._execution_count

    @execution_count.setter
    def execution_count(self, value):
        self._execution_count = value

    def __init__(self, **kwargs):
        super(BiochamKernel, self).__init__(**kwargs)
        self._execution_count = 0
        self._start_biocham()

    def _start_biocham(self):
        """Start the Biocham process"""
        self.biocham = replwrap.REPLWrapper(
            'biocham --jupyter',
            'biocham: ',
            None,
            continuation_prompt='|:'
        )
        # log = open('foo.log', 'w')
        # self.biocham.child.logfile = log

    def do_execute(self, code, silent, store_history=True,
                   user_expressions=None, allow_stdin=False):
        payload, image_filenames = [], []
        status = 'ok'

        # inform IPython users that biocham does not support shell kernel
        if code.startswith('!'):
            output = 'No system kernel available.'

        elif code.startswith('%') and \
                not code.startswith('% ') and '\n' not in code:
            output, payload = self._do_magic(code[1:])

        else:
            code = '\n'.join([line.strip() for line in code.splitlines() if
                              line.strip()])
            try:
                if code:
                    output = self.biocham.run_command(code,
                                                      timeout=self.timeout)
                else:
                    output = ''
                image_filenames, output = extract_image_filenames(output)
                if output.startswith('ERROR:'):
                    status = 'error'
            except exceptions.TIMEOUT:
                self.biocham.child.kill(SIGINT)
                self.biocham.run_command('a')
                output = 'non-terminated command'
                image_filenames = []
                status = 'error'

        if image_filenames:
            for filename in image_filenames:
                try:
                    display_data_for_image(filename)
                except ValueError as excpt:
                    message = {'name': 'stdout', 'text': str(excpt)}
                    self.send_response(self.iopub_socket, 'stream', message)
                    status = 'error'

        if not silent and output:
            if status == 'error':
                self.send_response(self.iopub_socket,
                                   'error',
                                   {
                                       'execution_count': self.execution_count,
                                       'ename': '',
                                       'evalue': output,
                                       'traceback': []
                                   })
            self.send_response(self.iopub_socket,
                               'execute_result',
                               {
                                   'execution_count': self.execution_count,
                                   'data': {'text/plain': output},
                                   'metadata': {},
                               })

        return {
            'status': status,
            'ename': '',
            # The base class increments the execution count
            'execution_count': self.execution_count,
            'payload': payload,
            'user_expressions': user_expressions,
        }

    def do_complete(self, code, cursor_pos):
        current = code[:cursor_pos]
        prefix = self.command_sep.split(current)[-1]
        return {
            'status': 'ok',
            'cursor_start': cursor_pos - len(prefix),
            'cursor_end': cursor_pos,
            'matches': _find(prefix),
        }

    def _do_magic(self, magic):
        '''handle biocham kernel %magic
        returns a pair output_string, payload'''
        if magic.startswith('load '):
            bcfile = magic[5:].split()[0]
            if not bcfile.endswith('.bc') or bcfile.startswith('.'):
                return 'Cannot read {}'.format(bcfile), []
            try:
                with open(bcfile, 'r') as bcinput:
                    lines = bcinput.read().split('.\n')
                # create a cell after current cell for each dotted command
                return 'loading {}'.format(bcfile), [{
                    'source': 'set_next_input',
                    'text': line.strip() + '.',
                    'replace': False,
                } for line in reversed(lines) if line.strip()]
            except FileNotFoundError:
                return "File doesn't exists", []

        if magic.startswith('timeout '):
            self.timeout = int(magic[8:].split()[0])
            return 'Timeout set to ' + str(self.timeout), []

        if magic.startswith('slider '):
            parameters = magic[7:].split()

            list_parameters = self.biocham.run_command('list_parameters.')
            current_val = []
            maximum = []
            for par in parameters:
                cur = re.search(r'] parameter\({}=([^)]*)\)'.format(par),
                                list_parameters)
                if cur is None or float(cur.group(1)) == 0:
                    current_val.append(float(0))
                    maximum.append(float(10))
                else:
                    current_val.append(float(cur.group(1)))
                    maximum.append(float(cur.group(1)) * 10)

            def scale(value):
                """Returns the number of decimals for a given value
                """
                # this cast is needed as otherwise precision gets wild
                value = str(value)
                return - Decimal(value).as_tuple().exponent

            def readout_format(value):
                f = scale(value)
                return '.{}f'.format(f)

            def step(value):
                """Returns step for a given value, cannot be inferior to 0.001
                otherwise widget will round step to 0.1
                """
                f = scale(value)
                if f == 0:
                    # if parameter value has no decimal
                    return len(value) - 1
                return float(10**-scale(value))

            display_ui = [widgets.FloatSlider(
                description=par,
                value=cur,
                min=0,
                max=max_val,
                step=step(cur),
                continuous_update=False,
                readout_format=readout_format(cur)) for (par, cur, max_val) in
                          zip(parameters, current_val, maximum)]

            for ui_item in display_ui:
                display(ui_item)
            # show a first result as placeholder
            image_filenames, _ = extract_image_filenames(
                self.biocham.run_command('numerical_simulation. plot.'))
            handle = display_data_for_image(image_filenames[0])
            if handle is not None:
                handle, data_source = handle

            def on_change(change):
                '''observer for the changes of the slider in the notebook'''
                self.biocham.run_command(
                    'parameter({param}={value}).'.format(
                        param=change['owner'].description,
                        value=change['new']
                    ))
                # run a simulation with default options
                self.biocham.run_command('numerical_simulation.',
                                         timeout=self.timeout)
                # plot and get corresponding HTML output

                image_filenames, _ = extract_image_filenames(
                    self.biocham.run_command('plot.'))
                try:
                    # If slider is at max value, new max value
                    if change.new == change.owner.max:
                        change.owner.max *= 10

                    display_data_for_image(
                        image_filenames[0],
                        handle, data_source
                    )

                except IndexError:
                    print('No plot to render.')

            for ui_item in display_ui:
                ui_item.observe(on_change, 'value')

            return '', []

        return '''The available kernel are:
    %lsmagic\tLists available kernel
    %load [file.bc]\tImport a biocham file as a notebook cell
    %slider <parameter> [parameter parameter]\tCreates a slider to change \
given parameter(s) in default simulation
''', []

    def do_apply(self, content, bufs, msg_id, reply_metadata):
        '''deprecated'''
        pass

    def do_clear(self):
        '''deprecated'''
        pass


def _find(prefix):
    '''find matching commands in the global command list'''
    matches = []
    index = bisect_left(commands, prefix)
    while commands[index].startswith(prefix):
        matches.append(commands[index])
        index += 1
    return matches