docs: 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