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