Update a mailing list member with a given address
439542
def update(member_address, options={})
      params = {:address => member_address}
      Mailgun.submit :put, list_member_url(member_address), params.merge(options)
    end
973117
def cli(ctx, email, first_name, last_name, password, metadata={}):
    
    return ctx.gi.users.update_user(email, first_name, last_name, password, metadata=metadata)
1057527
def shippingaddress_update(self, tid, session, **kwargs):
        ''''''
        request = TOPRequest('taobao.trade.shippingaddress.update')
        request['tid'] = tid
        for k, v in kwargs.iteritems():
            if k not in ('receiver_name','receiver_phone','receiver_mobile','receiver_state','receiver_city','receiver_district','receiver_address','receiver_zip') or v==None: continue
            request[k] = v
        self.create(self.execute(request, session)['trade'])
        return self
897310
def email_address_to_list(email_address):
    """"""
    realname, address = email.utils.parseaddr(email_address)
    return (
        [address, realname] if realname and address else
        [email_address, email_address]
    )
833293
public function setToEmailAddressField() {

        // get the mapped recipient (valid because $this->isInboundEmailToEmailAddressMapToUser() is already done)
        $mappedRoutes = config('lasallecmsmailgun.inbound_map_mailgun_routes_with_user_email_address');

        foreach ($mappedRoutes as $route => $user) {

            // if "from" email address is the same as the route specified in the config...
            if ($this->request->input('recipient') == $route) {
                return $user;
            }
        }
    }
988254
def addSubscribers(self, emails_list):
        

        if not hasattr(emails_list, "__iter__"):
            error_msg = "Input parameter 'emails_list' is not iterable"
            self.log.error(error_msg)
            raise exception.BadValue(error_msg)

        # overall flag
        existed_flags = False

        headers, raw_data = self._perform_subscribe()
        for email in emails_list:
            existed_flag, raw_data = self._add_subscriber(email, raw_data)
            existed_flags = existed_flags and existed_flag

        if existed_flags:
            return

        self._update_subscribe(headers, raw_data)
        self.log.info("Successfully add subscribers: %s for <Workitem %s>",
                      emails_list, self)
911485
def update(self, **kwargs):
        

        item = self._client['users/*/lists/*'].update(self.username, self.id, return_type='data', **kwargs)

        if not item:
            return False

        self._update(item)
        return True
620453
def update(self, emailAddress=None, ttl=None, comment=None):
        
        return self.manager.update_domain(self, emailAddress=emailAddress,
                ttl=ttl, comment=comment)
1259029
def update(cls, domain, source, dest_add, dest_del):
        """"""
        result = None

        if dest_add or dest_del:
            current_destinations = cls.get_destinations(domain, source)
            fwds = current_destinations[:]
            if dest_add:
                for dest in dest_add:
                    if dest not in fwds:
                        fwds.append(dest)
            if dest_del:
                for dest in dest_del:
                    if dest in fwds:
                        fwds.remove(dest)

            if ((len(current_destinations) != len(fwds))
                    or (current_destinations != fwds)):
                cls.echo('Updating mail forward %s@%s' % (source, domain))
                options = {'destinations': fwds}
                result = cls.call('domain.forward.update', domain, source,
                                  options)

        return result
683444
def update(id, url=default_webhook_url)
      params = {:url => url}
      Mailgun.submit :put, webhook_url(id), params
    end
657093
def updateMember(self, data, address, id, headers=None, query_params=None, content_type="application/json"):
        
        uri = self.client.base_url + "/network/"+id+"/member/"+address
        return self.client.post(uri, data, headers, query_params, content_type)
1076612
def create(address, options={})
    	params = {:address => address}
      Mailgun.submit :post, list_url, params.merge(options)
    end
951978
def email(email_address):
    """"""
    if not email_address:
        click.secho(dtool_config.utils.get_user_email(CONFIG_PATH))
    else:
        click.secho(dtool_config.utils.set_user_email(
            CONFIG_PATH,
            email_address
        ))
1086145
def add_email_addresses(self, addresses=[]):
        
        json = []
        if addresses:
            url = self._build_url('user', 'emails')
            json = self._json(self._post(url, data=addresses), 201)
        return json
919974
def update(self, title, unsubscribe_page, confirmed_opt_in,
               confirmation_success_page, unsubscribe_setting="AllClientLists",
               add_unsubscribes_to_supp_list=False, scrub_active_with_supp_list=False):
        """"""
        body = {
            "Title": title,
            "UnsubscribePage": unsubscribe_page,
            "ConfirmedOptIn": confirmed_opt_in,
            "ConfirmationSuccessPage": confirmation_success_page,
            "UnsubscribeSetting": unsubscribe_setting,
            "AddUnsubscribesToSuppList": add_unsubscribes_to_supp_list,
            "ScrubActiveWithSuppList": scrub_active_with_supp_list}
        response = self._put("/lists/%s.json" % self.list_id, json.dumps(body))
543536
def formatted
      list = element.addresses.map { |a| a.format }
      Mail::AddressContainer.new(self, list)
    end
1308719
def custom_update_user(sender, instance, attributes, user_modified, **kargs):
    
    for k, v in attributes.items():
        u = set.intersection(set(v), set([u'true', u'false']))
        if u:
            setattr(instance, k, u.pop() == u'true')
    return True