Update the "current area" to be the area with this UUID.

        :param str area_uuid: The RFC4122-compliant UUID of the Upload Area.
976787
def select_area(self, area_uuid):
        

        self._config.upload.current_area = area_uuid
        self.save()
939203
def lock_area(self, code, index):
        
        logger.debug("locking area code %s index %s" % (code, index))
        return self.library.Srv_LockArea(self.pointer, code, index)
241738
def _handle_end_area(self):
        
        self._result.append(Area(result=self._result, **self._curr))
        self._curr = {}
1067168
def subject_area(soup):
    
    subject_area = []

    tags = raw_parser.subject_area(soup)
    for tag in tags:
        subject_area.append(node_text(tag))

    return subject_area
773544
def poll(self):
        
        response = self.client.protocol.get('/uploads/{upload_id}',
                                            upload_id=self.upload_id,
                                            check_for_errors=False)

        self.update_from_response(response)
125643
private function AddAreasField()
    {
        $name = 'Areas';
        $field = Input::Text($name, join(', ' , $this->areaNames));
        $this->AddField($field);
        if ($this->layout->Exists())
        {
            $field->SetHtmlAttribute('readonly', 'readonly');
        }
        else
        {
            $this->SetTransAttribute($name, 'placeholder');
            $this->SetRequired($name);
        }
    }
698867
def upload(self, wg_uuid, file_path, description=None, parent=None):
        
        url = "%(base)s/%(wg_uuid)s/nodes" % {
            'base': self.local_base_url,
            'wg_uuid': wg_uuid
        }
        param = {}
        if parent:
            # I use only the last folder uuid, the first ones are not really useful
            if isinstance(parent, (list,)):
                if len(parent) >= 1:
                    parent = parent[-1]
            param['parent'] = parent
        encode = urllib.urlencode(param)
        if encode:
            url += "?"
            url += encode
        return self.core.upload(file_path, url, description)
510373
def register_area(self, area_code, index, userdata):
        
        size = ctypes.sizeof(userdata)
        logger.info("registering area %s, index %s, size %s" % (area_code,
                                                                index, size))
        size = ctypes.sizeof(userdata)
        return self.library.Srv_RegisterArea(self.pointer, area_code, index,
                                             ctypes.byref(userdata), size)
1089317
def update_user_attributes(self, id, old_attrs, new_attrs):
        
        from alerta.utils.collections import merge
        merge(old_attrs, new_attrs)
        attrs = {k: v for k, v in old_attrs.items() if v is not None}
        update = {
            '$set': {'attributes': attrs}
        }
        response = self.get_db().users.update_one({'_id': {'$regex': '^' + id}}, update=update)
        return response.matched_count > 0
548077
def update_user(self, user, email=None, username=None,
            uid=None, defaultRegion=None, enabled=None):
        
        user_id = utils.get_id(user)
        uri = "users/%s" % user_id
        upd = {"id": user_id}
        if email is not None:
            upd["email"] = email
        if defaultRegion is not None:
            upd["RAX-AUTH:defaultRegion"] = defaultRegion
        if username is not None:
            upd["username"] = username
        if enabled is not None:
            upd["enabled"] = enabled
        data = {"user": upd}
        resp, resp_body = self.method_put(uri, data=data)
        if resp.status_code in (401, 403, 404):
            raise exc.AuthorizationFailure("You are not authorized to update "
                    "users.")
        return User(self, resp_body)
775109
def by_puuid(self, region, encrypted_puuid):
        
        url, query = SummonerApiV4Urls.by_puuid(
            region=region, encrypted_puuid=encrypted_puuid
        )
        return self._raw_request(self.by_puuid.__name__, region, url, query)
239450
def update(self, response, **kwargs):
        '''
        
        '''
        response_cls = super(
            LocationResponseClassLegacyAccessor, self)._get_instance(**kwargs)
        if response_cls:
            setattr(response_cls, self.column, self.accessor(response))
            setattr(
                response_cls, self.venue_column, self.venue_accessor(response))
            _action_and_commit(response_cls, session.add)
1330352
def update(self, campaign_id, area, nick=None):
        ''''''
        request = TOPRequest('xxxxx.xxxxx.campaign.area.update')
        request['campaign_id'] = campaign_id
        request['area'] = area
        if nick!=None: request['nick'] = nick
        self.create(self.execute(request), fields=['success','result','success','result_code','result_message'], models={'result':CampaignArea})
        return self.result
400208
def _maybe_update(self, user, attribute, new_value):
        
        old_value = getattr(user, attribute)
        if new_value != old_value:
            self.stderr.write(
                _('Setting {attribute} for user "{username}" to "{new_value}"').format(
                    attribute=attribute, username=user.username, new_value=new_value
                )
            )
            setattr(user, attribute, new_value)
74873
function updateApplication(uuid, opts, callback) {
    assert.string(uuid, 'uuid');
    assert.object(opts, 'opts');

    return (this.put(sprintf('/applications/%s', uuid), opts, callback));
}
447560
def uuid_to_uid(uuid)
      uuid = Integer(uuid)
      if uuid >= 0 && uuid <= MAX_UUID
        10_000 + uuid
      else
        raise RangeError, "#{uuid} is not within (0..#{MAX_UUID})"
      end
    end
1101214
public static <PS, SEG, S> Consumer<PlainTextChange> applyPlainTextChange(GenericStyledArea<PS, SEG, S> area) {
        return change -> area.replaceText(change.getPosition(), change.getRemovalEnd(), change.getInserted());
    }