Update the specified object from slick.  You specify the object as a parameter, using the parent object as
        a function.  Example:
        proj = slick.projects.findByName("foo")
        ... update proj here
        slick.projects(proj).update()
517488
def update(self):
        
        obj = self.data
        url = self.getUrl()

        # hopefully when we discover what problems exist in slick to require this, we can take the loop out
        last_stats_code = None
        last_body = None
        for retry in range(3):
            try:
                json_data = obj.to_json()
                self.logger.debug("Making request to slick at url %s, with data: %s", url, json_data)
                r = requests.put(url, data=json_data, headers=json_content)
                self.logger.debug("Request returned status code %d", r.status_code)
                if r.status_code is 200:
                    return self.model.from_dict(r.json())
                else:
                    last_stats_code = r.status_code
                    last_body = r.text
                    self.logger.warn("Slick status code: %d", r.status_code)
                    self.logger.warn("Body of what slick returned: %s", r.text)
            except BaseException as error:
                self.logger.warn("Received exception while connecting to slick at %s", url, exc_info=sys.exc_info())
                traceback.print_exc()
        raise SlickCommunicationError(
            "Tried 3 times to request data from slick at url %s without a successful status code.  Last status code: %d, body: %s", url, last_stats_code, last_body)
1093347
def update(self, *args, **kwargs):
        
        if args:
            for arg in args:
                if not isinstance(arg, ScriptField):
                    raise InvalidParameter("%s this must be a ScriptField or derivated" % arg)

        query = self._build_query()
        connection = self.model._meta.dj_connection
        query.fields = ["_id", "_type", "_index"]
        # results = connection.connection.search(query, indices=connection.database, doc_types=self.type,
        #                             model=self.model, scan=True)

        conn = connection.connection
        results = conn.search(query, indices=connection.database, doc_types=self.type, scan=True)

        for item in results:
            if kwargs:
                conn.update(item._meta.index, item._meta.type, item._meta.id, document=kwargs, bulk=True)
            for script in args:
                conn.update(item._meta.index, item._meta.type, item._meta.id,
                            script=script.script, lang=script.lang, params=script.params, bulk=True)

        connection.connection.flush_bulk(True)
        # Clear the result cache, in case this QuerySet gets reused.
        self._result_cache = None
599907
def perform_update(self, data, instance):
        

        for key, val in data.items():
            setattr(instance, key, val)
327874
def update(self, data=None, **kwargs):
        
        if data is None:
            data = {}
        data.update(kwargs)
        return self.model.write([self.id], data)
686657
async def update(self):
    '''
    
    '''
    keys = self.extras.keys()
    self.extras = {}
    for key in keys:
      try:
        func = getattr(self, key, None)
        if callable(func):
          func()
      except:
        pass
546314
def update(params)
      raise ArgumentError, "Only Hash parameter can be passed to table update method" unless params.is_a?(Hash)
      where = params.delete(:where)

      table_proc = TableProcedure.new(@schema, self, :update)
      table_proc.add_set_arguments(params)
      table_proc.add_where_arguments(where) if where
      call = ProcedureCall.new(table_proc, table_proc.argument_values)
      call.exec
    end
593677
function(obj, sendUpdatedEvt) {
	   this.subField.setValue(obj.value, false);
	   inputEx.TreeField.superclass.setValue.call(this, obj.childValues, sendUpdatedEvt);
	}
607939
def update(self, **kwargs):
        
        if not self.object_id:
            return False

        url = self.build_url(
            self._endpoints.get('item').format(id=self.object_id))

        data = {self._cc(key): value for key, value in kwargs.items() if
                key in {'name',
                        'description'}}  # convert keys to protocol casing
        if not data:
            return False

        response = self.con.patch(url, data=data)
        if not response:
            return False

        new_data = response.json()

        for key in data:
            value = new_data.get(key, None)
            if value:
                setattr(self, self.protocol.to_api_case(key), value)

        return True
183564
public void update(Object object) {
        try {
            persistenceManager.saveEntity((IManagedEntity) object);
        } catch (InitializationException ignore){}
        catch (Exception e) {
            e.printStackTrace();
        }
    }
487582
@SuppressWarnings("unchecked")
    private void updateMap(Map<String, Object> parentMap, String paramName, Object paramValue) {
        Object currentValue = parentMap.get(paramName);
        if (currentValue == null || !(currentValue instanceof Map)) {
            if (paramValue instanceof Map) {
                parentMap.put(paramName, paramValue);
            } else {
                parentMap.put(paramName, paramValue.toString());
            }
        } else {
            Utils.require(paramValue instanceof Map,
                          "Parameter '%s' must be a map: %s", paramName, paramValue.toString());
            Map<String, Object> currentMap = (Map<String, Object>)currentValue;
            Map<String, Object> updateMap = (Map<String, Object>)paramValue;
            for (String subParam : updateMap.keySet()) {
                updateMap(currentMap, subParam, updateMap.get(subParam));
            }
        }
    }
36935
def flex_update_obj(source, target, __silent, *fields, **field_map):
    '''  '''
    source_dict = source.__dict__ if hasattr(source, '__dict__') else source
    if not fields:
        fields = source_dict.keys()
    for f in fields:
        if f not in source_dict and __silent:
            continue
        target_f = f if f not in field_map else field_map[f]
        setattr(target, target_f, source_dict[f])
625172
def _update(self, api_obj):
    """"""
    if not isinstance(self, api_obj.__class__):
      raise ValueError(
          "Class %s does not derive from %s; cannot update attributes." %
          (self.__class__, api_obj.__class__))

    for name in self._get_attributes().keys():
      try:
        val = getattr(api_obj, name)
        setattr(self, name, val)
      except AttributeError, ignored:
        pass
1006852
function do_update(self, ObjType, obj, orig_data) {
	return nr_fcall("nopg:do_update", function() {
		var query, params, data, where = {};

		if(obj.$id) {
			where.$id = obj.$id;
		} else if(obj.$name) {
			where.$name = obj.$name;
		} else {
			throw new TypeError("Cannot know what to update!");
		}

		if(orig_data === undefined) {
			// FIXME: Check that `obj` is an ORM object
			data = obj.valueOf();
		} else {
			data = (new ObjType(obj)).update(orig_data).valueOf();
		}

		//debug.log('data = ', data);

		// Select only keys that start with $
		var keys = ARRAY(ObjType.meta.keys)
			// Remove leading '$' character from keys
			.filter(first_letter_is_dollar)
			.map( parse_keyword_name )
			// Ignore keys that aren't going to be changed
			.filter(function(key) {
				return data.hasOwnProperty(key);
			// Ignore keys that were not changed
			}).filter(function(key) {
				return json_cmp(data[key], obj['$'+key]) ? false : true;
			});

		//debug.log('keys = ', keys.valueOf());

		// Return with the current object if there is no keys to update
		if(keys.valueOf().length === 0) {
			return do_select(self, ObjType, where);
		}

		// FIXME: Implement binary content support
		query = "UPDATE " + (ObjType.meta.table) + " SET "+ keys.map(function(k, i) { return k + ' = $' + (i+1); }).join(', ') +" WHERE ";

		if(where.$id) {
			query += "id = $"+ (keys.valueOf().length+1);
		} else if(where.$name) {
			query += "name = $"+ (keys.valueOf().length+1);
		} else {
			throw new TypeError("Cannot know what to update!");
		}

		query += " RETURNING *";

		params = keys.map(function(key) {
			return data[key];
		}).valueOf();

		if(where.$id) {
			params.push(where.$id);
		} else if(where.$name){
			params.push(where.$name);
		}

		return do_query(self, query, params);
	});
}
699261
function update(client) {
  var id = client.id;

  // Auto-remove when this client is closed.
  client.once('closed', function() {
    remove(id);
  });

  var info = find(client);
  if(!info) {
    log.warn('No ClientInfo object found for client.id=%s', id);
    return;
  }
  info.username = client.username;
}
385555
def update(self, *args, **kwargs):
        
        d = {}
        d.update(*args, **kwargs)
        for key, value in d.items():
            self[key] = value
1203467
def update(self, *args, **kwargs):
        

        dict.update(self, *args, **kwargs)
        self.__dict__.update(*args, **kwargs)
534598
def update_from(self, mapping):
        
        for key, value in mapping.items():
            if key in self:
                if isinstance(value, Parameter):
                    value = value.value
                self[key].value = value