docs: def play(self, *inputs, **named_inputs):
          """ Run the selected components of the block. The selected components 
          are run with the already setted options.
  
          .. warning:: Defaut 'multiple' behavior is a **pipeline** !
  
          :param *inputs: arguments (i.e. inputs) to give to the components
          """
          # TODO: multi mode option(False, pipeline, map)
          self.validate() # TODO what if validate fails ?
          # intialise run meta data
          start = time.time()
          self.meta = PlayMeta(self.name)
              ### manage inputs
          if len(inputs) and len(named_inputs):
              raise ValueError("Either `inputs` or `named_inputs` should be provided, not both !")
          # default input name (so also the default last_output_name)
          if len(named_inputs):
              if self.in_name is None:
                  raise ValueError("named inputs given, but the block input's names are unknow")
              if set(self.in_name) != set(named_inputs.keys()):
                  raise ValueError("Inputs names are not matching with block input's names")
              inputs = [named_inputs[in_name] for in_name in self.in_name]
  
          _break_on_error = True
          results = {}
          # run
          for comp_name in self.selected():
              # get the component
              comp = self._components[comp_name]
              # get the options
              if isinstance(comp, Optionable):
                  # note: we force the hidden values only if the call is not
                  # decorated by a "check" (that already force the hidden values)
                  force_hidden = not (hasattr(comp.__call__, '_checked') and comp.__call__._checked)
                  options = comp.get_options_values(hidden=force_hidden)
              else:
                  options = {}
              # prepare the Play meta data
              comp_meta_res = BasicPlayMeta(comp)
              # it is register right now to be sur to have the data if there is an exception
              self.meta.append(comp_meta_res)
              comp_meta_res.run_with(inputs, options)
  
              # some logging
              argstr = [repr(arg)[:100].replace('\n', '') for arg in inputs]
              self._logger.debug("""'%s' playing: %s
                  component: %s,
                  args=%s,
                  kwargs=%s""" % (self._name, comp.name, comp, "\n\t\t".join(argstr), options))
  
              # run the component !
              try:
                  # multi = False or pipeline
                  # given that the input is also the returning value
                  # This behavior allows to modify the data given in input.
                  # actually same arg if given several times 
                  # but may be transformed during the process
                  # then finally returned
                  results[self.out_name] = comp(*inputs, **options)
                  #TODO: add validation on inputs name !
  
                  # TODO implements different mode for multiple 
                  # another way would be declaring a list var outside the loop,
                  # then append result of each call to the components __call__
                  # and finally returns all computed results
                  #   map( lambda x : x(*arg), *components )
                  # >>> results.append( comp(*args, **options) )
                  # >>> return *results
  
              # TODO catch warnings TODO
              # warning may be raised for many reasons like:
              # * options has been modified
              # * deprecation
              # * pipeline inconsistency 
              # * invalid input (graph with no edge ...)
              except Exception as err:
                  # component error handling
                  comp_meta_res.add_error(err)
                  self._logger.error("error in component '%s': %s\n%s" % (comp.name, str(err), traceback.format_exc()))
                  if _break_on_error:
                      raise
              finally:
                  # store component walltime
                  now = time.time()
                  comp_meta_res.time = now - start
                  start = now
          #TODO: may return more than one value with multi=map 
          return results