Add a new command to the blueprint.

        :param name: The command name
        :type name: str

        :param parameters: The command parameters
        :type parameters: dict

        :rtype: Fluent
777683
def _add_command(self, name, **parameters):
        
        command = self._create_command(name, **parameters)
        self._commands.append(command)

        return command
33897
def _get_commands_by_name(self, blueprint, name):
        
        return list(filter(lambda value: value.name == name, blueprint.get_commands()))
493521
def add_command(self, command):
        
        self._commands.append(command)
        self._build_command_chain(command)
361648
def addParam(self, paramName, paramValue):
        

        if not paramName:
            raise ValueError('paramName cannot be empty')
        self._params[paramName] = paramValue
319716
def put_parameter(Name,
                  Value,
                  Description=None,
                  Type='String',
                  KeyId=None,
                  Overwrite=False,
                  AllowedPattern=None,
                  region=None,
                  key=None,
                  keyid=None,
                  profile=None):
    '''
    
    '''
    conn = __utils__['boto3.get_connection']('ssm', region=region, key=key, keyid=keyid, profile=profile)
    if Type not in ('String', 'StringList', 'SecureString'):
        raise AssertionError('Type needs to be String|StringList|SecureString')
    if Type == 'SecureString' and not KeyId:
        raise AssertionError('Require KeyId with SecureString')

    boto_args = {}
    if Description:
        boto_args['Description'] = Description
    if KeyId:
        boto_args['KeyId'] = KeyId
    if AllowedPattern:
        boto_args['AllowedPattern'] = AllowedPattern

    try:
        resp = conn.put_parameter(Name=Name, Value=Value, Type=Type, Overwrite=Overwrite, **boto_args)
    except conn.exceptions.ParameterAlreadyExists:
        log.warning("The parameter already exists."
                    " To overwrite this value, set the Overwrite option in the request to True")
        return False
    return resp['Version']
1032970
def create_command(self, name, operation, **kwargs):
        
        if not isinstance(operation, six.string_types):
            raise ValueError("Operation must be a string. Got '{}'".format(operation))

        name = ' '.join(name.split())

        client_factory = kwargs.get('client_factory', None)

        def _command_handler(command_args):
            op = CLICommandsLoader._get_op_handler(operation)
            client = client_factory(command_args) if client_factory else None
            result = op(client, **command_args) if client else op(**command_args)
            return result

        def arguments_loader():
            return list(extract_args_from_signature(CLICommandsLoader._get_op_handler(operation),
                                                    excluded_params=self.excluded_command_handler_args))

        def description_loader():
            return extract_full_summary_from_signature(CLICommandsLoader._get_op_handler(operation))

        kwargs['arguments_loader'] = arguments_loader
        kwargs['description_loader'] = description_loader

        cmd = self.command_cls(self.cli_ctx, name, _command_handler, **kwargs)
        return cmd
595250
def add_command(self, factory, main, name=None, context_kwargs=None):
        
        if name is None:
            name = factory.__name__.replace('_', '-')

        if context_kwargs is None:
            context_kwargs = {}

        short_desc, long_desc = parse_docstring(factory.__doc__)
        if long_desc:
            long_desc = short_desc + '\n\n' + long_desc

        # determine the absolute import string if relative
        if isinstance(main, str) and (
            main.startswith('.') or main.startswith(':')
        ):
            module = __import__(factory.__module__, None, None, ['__doc__'])
            package = package_for_module(module)
            if main in ['.', ':']:
                main = package.__name__
            else:
                main = package.__name__ + main

        self.commands[name] = CommandMeta(
            factory=factory,
            main=main,
            name=name,
            help=short_desc,
            description=long_desc,
            context_kwargs=context_kwargs,
        )
511243
def _add_stage(self, name):
        
        def stage_func(self, *args, **kwargs):
            """ Stage function.

            :param args: Positional arguments.
            :param kwargs: Keyword arguments.
            :return: Pipeline (for method chaining).
            """
            self._pipe.append(Stage(name, args, kwargs))
            return self

        setattr(Pipeline, name, stage_func)
413093
def add_command(self, cmd_name, *args):
        """"""
        self.__commands.append(Command(cmd_name, args))
232363
def act(self, cmd_name, param):
        
        command = getattr(self, cmd_name)
        if param:
            command(param)
        else:
            command()
993183
def call_command(self, name, *arguments, **options):
        
        command, defaults = get_command_and_defaults(
            name,
            exclude_packages=self.get_exclude_packages(),
            exclude_command_class=self.__class__)
        if command is None:
            raise management.CommandError(
                "Unknown command: {name:s}".format(
                    name=name))
        defaults.update(options)
        return command.execute(*arguments, **defaults)
750594
public void addParam(String name, String value) {
        if (name == null) {
            throw new NullPointerException("name");
        }
        if (value == null) {
            throw new NullPointerException("value");
        }
        params.add(new Param(name, value));
    }
186896
public void addParameters(Map<String, Object> parameters, boolean suppressNull) {
        
        for (String name : parameters.keySet()) {
            Object value = parameters.get(name);
            
            if (!suppressNull || value != null) {
                addParameter(name, value);
            }
        }
    }
348311
public void addParameter(String parameterName, int parameterStart, int parameterEnd) {
        addParameter(parameterName, parameterStart, parameterEnd, null, null);
    }
221429
void addParameter(String name, String value) {
        params.add(new Parameter(name, value));
    }
442667
def add_parameter(self, param_name, description=None, default=0, unit=None):
        

        if description is None:
            description = "Parameter called {}".format(param_name)

        if unit is None:
            unit = "-"
        
        name_check = lambda x: x['name'] == param_name
        name_check_list = list(filter(name_check, self.ext_params))
        if len(name_check_list) == 0:
            self.ext_params.append({'name': param_name, 'description': description, 'default': default, 'unit': unit})
        else:
            print('{} already exists - choose a different name'.format(param_name))
1315060
def add(options = {})
      self.options = options

      raise(ArgumentError, 'Mandatory param :name missing') unless options[:name]

      if options[:feature]
        features << options
        SafetyCone::ViewHelpers.add_method(options[:feature])
      else
        paths[make_key] = options
      end
    end