Edit this multireddit.

        Convenience function that utilizes
        :meth:`.MultiredditMixin.edit_multireddit` populating the `name`
        parameter.
511791
def edit(self, *args, **kwargs):
        
        return self.reddit_session.edit_multireddit(name=self.name, *args,
                                                    **kwargs)
675196
def edit_filter(self):
        """"""
        filters, valid = QInputDialog.getText(self, _('Edit filename filters'),
                                              _('Name filters:'),
                                              QLineEdit.Normal,
                                              ", ".join(self.name_filters))
        if valid:
            filters = [f.strip() for f in to_text_string(filters).split(',')]
            self.parent_widget.sig_option_changed.emit('name_filters', filters)
            self.set_name_filters(filters)
1126071
def edit(self, name, mark=False):
        
        self.api.edit(self, name, mark)
1122732
def rename(self):
        
        params = self.relation_name ^ (Optional(self.relation_name) +
                                       self.parenthesize(self.attribute_list))
        return self.parametrize(self.syntax.rename_op, params)
108555
def edit(self, title, state=github.GithubObject.NotSet, description=github.GithubObject.NotSet, due_on=github.GithubObject.NotSet):
        
        assert isinstance(title, (str, unicode)), title
        assert state is github.GithubObject.NotSet or isinstance(state, (str, unicode)), state
        assert description is github.GithubObject.NotSet or isinstance(description, (str, unicode)), description
        assert due_on is github.GithubObject.NotSet or isinstance(due_on, datetime.date), due_on
        post_parameters = {
            "title": title,
        }
        if state is not github.GithubObject.NotSet:
            post_parameters["state"] = state
        if description is not github.GithubObject.NotSet:
            post_parameters["description"] = description
        if due_on is not github.GithubObject.NotSet:
            post_parameters["due_on"] = due_on.strftime("%Y-%m-%d")
        headers, data = self._requester.requestJsonAndCheck(
            "PATCH",
            self.url,
            input=post_parameters
        )
        self._useAttributes(data)
651211
def edit_service(self, id_, **kwargs):
        
        data = self._wrap_dict("service", kwargs)
        return self.patch("/services/{}.json".format(id_), data=data)
45104
def edit(self, **kwargs):
        

        logger.debug('Job {0} changing name to {1}'.format(self.name, kwargs.get('name')))
        if not self.state.allow_edit_job:
            raise DagobahError('job cannot be edited in its current state')

        if 'name' in kwargs and isinstance(kwargs['name'], str):
            if not self.parent._name_is_available(kwargs['name']):
                raise DagobahError('new job name %s is not available' %
                                   kwargs['name'])

        for key in ['name']:
            if key in kwargs and isinstance(kwargs[key], str):
                setattr(self, key, kwargs[key])

        self.parent.commit(cascade=True)
738845
def add_parameter(self, field_name, param_name, param_value):
        
        try:
            self.fields[field_name]['params'][param_name] = param_value
        except Exception as ex:
            raise ScriptFieldsError("Error adding parameter %s with value %s :%s" % (param_name, param_value, ex))

        return self
440953
def auth_edit(name, **kwargs):
    
    ctx = Context(**kwargs)
    ctx.timeout = None
    ctx.execute_action('auth:group:edit', **{
        'storage': ctx.repo.create_secure_service('storage'),
        'name': name,
    })
14604
def edit_user(self, user_id, user_object):
        
        return self.user_service.editObject(user_object, id=user_id)
717736
def add_subreddit(self, subreddit, _delete=False, *args, **kwargs):
        
        subreddit = six.text_type(subreddit)
        url = self.reddit_session.config['multireddit_add'].format(
            user=self._author, multi=self.name, subreddit=subreddit)
        method = 'DELETE' if _delete else 'PUT'
        # The modhash isn't necessary for OAuth requests
        if not self.reddit_session._use_oauth:
            self.reddit_session.http.headers['x-modhash'] = \
                self.reddit_session.modhash
        data = {'model': dumps({'name': subreddit})}
        try:
            self.reddit_session.request(url, data=data, method=method,
                                        *args, **kwargs)
        finally:
            # The modhash isn't necessary for OAuth requests
            if not self.reddit_session._use_oauth:
                del self.reddit_session.http.headers['x-modhash']
684688
def name_replace(self, to_replace, replacement):
        """"""
        self.name = self.name.replace(to_replace, replacement)
583446
def edit(self):
        
        subprocess.call("{0} {1}".format(self.meta.editor,
                                         self.config_file), shell=True)
1017549
def modify_kls(self, name):
        """"""
        if self.kls is None:
            self.kls = name
        else:
            self.kls += name
821008
def edit_message_text(self, *args, **kwargs):

		''''''
		return super(MQBot, self).edit_message_text(*args, **kwargs)
532667
def add_parameter(self, name, value=None):
		
		if name not in self.__query:
			self.__query[name] = [value]
		else:
			self.__query[name].append(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))