Run the engine/block according to some inputs data and options
        
        It is called from :func:`play`
        
        :param inputs_data: dict of input data
        :param options: engine/block configuration dict

def run(self, inputs_data, options):
        """ Run the engine/block according to some inputs data and options
        
        It is called from :func:`play`
        
        :param inputs_data: dict of input data
        :param options: engine/block configuration dict
        """
        ### configure the engine
        try:
            self.engine.configure(options)
        except ValueError as err:
            raise
            abort(406, err)  # Not Acceptable

        ### Check inputs
        needed_inputs = self.engine.needed_inputs()
        # add default
        for inname in needed_inputs:
            #print(inname)
            if inname not in inputs_data \
                    and inname in self._inputs \
                    and self._inputs[inname].default is not None:
                inputs_data[inname] = self._inputs[inname].default
        # check if all needed inputs are possible
        if not all(inname in self._inputs for inname in needed_inputs):
            #Note: this may be check staticly
            missing = [inname for inname in needed_inputs if inname not in self._inputs]
            raise ValueError("Inputs %s are needed but not declared." % missing)
        # check if all inputs are given
        if not all(inname in inputs_data for inname in needed_inputs):
            # configuration error
            missing = [inname for inname in needed_inputs if inname not in inputs_data]
            raise ValueError("Inputs %s are missing." % missing)
        #
        ### parse inputs (and validate)
        inputs = {}
        for inname in needed_inputs:
            input_val = self._inputs[inname].parse(inputs_data[inname])
            self._inputs[inname].validate(input_val)
            inputs[inname] = input_val
        #
        ### run the engine
        error = False # by default ok
        try:
            raw_res = self.engine.play(**inputs)
        except ReliurePlayError as err:
            # this is the Reliure error that we can handle
            error = True
        finally:
            pass
        #
        ### prepare outputs
        outputs = {}
        results = {}
        if not error:
            # prepare the outputs
            for out_name, raw_out in six.iteritems(raw_res):
                if out_name not in self._outputs:
                    continue
                serializer = self._outputs[out_name]['serializer']
                params = self._outputs[out_name].get('parameters', {})
                # serialise output
                if serializer is not None:
                    results[out_name] = serializer.serialize(raw_res[out_name], **params)
                else:
                    results[out_name] = raw_res[out_name]
        ### prepare the retourning json
        # add the results
        outputs["results"] = results
        ### serialise play metadata
        outputs['meta'] = self.engine.meta.as_dict()
        #note: meta contains the error (if any)
        return outputs