Update the fields of an item state.

 Supply a hash of string keyed data retrieved from the Trello API representing
 an item state.
969331
def update_fields(fields)
      attributes[:id]      = fields['id'] || attributes[:id]
      attributes[:state]   = fields['state'] || attributes[:state]
      attributes[:item_id] = fields['idCheckItem'] || attributes[:item_id]
      self
    end
1225324
def _update_on_fields(prev_ele, new_ele):
    '''
    
    '''
    fields_update = dict(
        (prop_name, prop_val)
        for prop_name, prop_val in six.iteritems(new_ele)
        if new_ele.get(prop_name) != prev_ele.get(prop_name) or prop_name in _MATCH_KEYS
    )
    if len(set(fields_update.keys()) | set(_MATCH_KEYS)) > len(set(_MATCH_KEYS)):
        if 'id' not in fields_update:
            # in case of update, the ID is necessary
            # if not specified in the pillar,
            # will try to get it from the prev_ele
            fields_update['id'] = prev_ele['id']
        return fields_update
667547
def update(self, **kwds):
        
        result = self._client.tag.update(self, **kwds)
        self._replace_fields(result.get_fields())
1255650
def dynamic_content_item_variant_update(self, item_id, id, data, **kwargs):
        ""
        api_path = "/api/v2/dynamic_content/items/{item_id}/variants/{id}.json"
        api_path = api_path.format(item_id=item_id, id=id)
        return self.call(api_path, method="PUT", data=data, **kwargs)
707689
function updateKeys() {
      keys = [];

      for (var key in items) {
        keys.push(key);
      }

      LocalStorage.length = keys.length;
    }
599907
def perform_update(self, data, instance):
        

        for key, val in data.items():
            setattr(instance, key, val)
675047
def update(self, key, value):
        
        if not isinstance(value, dict):
            raise BadValueError(
                'The value {} is incorrect.'
                ' Values should be strings'.format(value))
        if key in self.data:
            v = self.get(key)
            v.update(value)
        else:
            v = value
        self.set(key, v)
861725
def update_from_dict(self, data_dict):
        
        for k, v in data_dict.items():
            setattr(self, k, v)
        if "item_queue_id" in data_dict:
            self.id = data_dict["item_queue_id"]
1048994
def update_attributes(datas)
      search_attributes.each do |val|
        self.send("#{val.field}=", val.cast_value(datas[val.field]))
      end
    end
285856
def update(self, key, item):
        
        return lib.zhash_update(self._as_parameter_, key, item)
240890
def update(self, data):
        
        result = None
        if data:
            _dumps = self._dumps
            data = {
                key: _dumps(value)
                for key, value in data.items()}
            result = self._client.hmset(self.key_prefix, data)
        return result
350518
def update(self, item, dry_run=None):
        """"""
        logger.debug('Updating item. Item: {item} Table: {namespace}'.format(
            item=item,
            namespace=self.namespace
        ))

        if not dry_run:
            self.table.put_item(Item=item)

        return item
224714
def update(self, **kwargs):
        
        data = []
        for cl in self:
            for classification_item in cl.list:
                class_item_dict = dict()
                for field in classification_item.fields:
                    class_item_dict[field] = getattr(classification_item, field)
                data.append(class_item_dict)
        self.load(self.client.put(self.url, data=data))
        return self
536094
def update(self, key: str, data: np.ndarray) -> None:
        
        self.data[key] = data
627109
def update(self, json_state):
        
        self._json_state.update(
            {k: json_state[k] for k in json_state if self._json_state.get(k)})
        self._update_name()
749831
def update_fields(self, updates):
        

        for field in updates:
            if self._valid_field(field):
                self._track_changes.add(field)
            else:
                raise ValueError('"{}" is not a valid internal field name'.format(field))

        # Update existing instance of fields, or create a fields instance if needed
        if self.fields:
            self.fields.update(updates)
        else:
            self.fields = updates
1159956
def update(self, data):
        
        if data:
            _dumps = self._dumps
            zargs = [
                _dumps(x) if (i % 2 == 1) else x
                for y in data.items()
                for i, x in enumerate(reversed(y))
            ]
            return self._client.zadd(self.key_prefix, *zargs)