If setting ``key=value`` would result in a contradiction, iterate over contradicted ``(turn, tick)``s.
172101
def _iter_future_contradictions(entity, key, turns, branch, turn, tick, value):
        """"""
        # assumes that all future entries are in the plan
        if not turns:
            return
        if turn in turns:
            future_ticks = turns[turn].future(tick)
            for tck, newval in future_ticks.items():
                if newval != value:
                    yield turn, tck
            future_turns = turns.future(turn)
        elif turns.rev_gettable(turn):
            future_turns = turns.future(turn)
        else:
            future_turns = turns
        if not future_turns:
            return
        for trn, ticks in future_turns.items():
            for tick, newval in ticks.items():
                if newval != value:
                    yield trn, tick
112745
def setValue(self, key, value):
        
        if self._customFormat:
            self._customFormat.setValue(key, value)
        else:
            super(XSettings, self).setValue(key, wrapVariant(value))
69279
def set(key, value, overwrite: true)
      result = if overwrite
        self.connection.hset(@key, key, value)
      else
        self.connection.hsetnx(@key, key, value)
      end

      return coerce_bool(result)
    end
350550
def _set_intvals(kws, keys):
        """"""
        for key in keys:
            if key in kws:
                kws[key] = int(kws[key])
1075138
def has(self, key, mtime=None):
        
        v = self.__values.get(key, None)
        if not v:
            return False
        if self.check_modified_time:
            mtime = self._get_mtime(key, mtime)
            if mtime != self.__modified_times[key]:
                del self[key]
                return False
        return True
212667
def then_then_returned_element_have_a_key(context, line, key, value):
    
    line = int(line)
    data = context.apiRequest.data
    assert 0 <= line < len(data)
    row = data[line]
    assert key in row
    assert row[key] == value
674308
def set(self, key, value):
        
        return self.__setitem__(key, value, force=True)
1269476
def setKey(self, key, value):
		
		data = self.getDictionary()
		data[key] = value
		self.setDictionary(data)
83955
def node_val_set(self, graph, node, key, branch, turn, tick, value):
        """"""
        if (branch, turn, tick) in self._btts:
            raise TimeError
        self._btts.add((branch, turn, tick))
        graph, node, key, value = map(self.pack, (graph, node, key, value))
        self._nodevals2set.append((graph, node, key, branch, turn, tick, value))
206296
def setitem(self, key, value):
        
        with self.lock:
            self.tbl[key] = value
15261
private boolean arrayKeyValueExists(String key, String value) {
    if (visitedPost.containsKey(key)) {
      for(String s : visitedPost.get(key)) {
        if(s.equals(value)) {
          return true;
        }
      }
    }

    return false;

  }
76311
def _maybe_cast_indexer(self, key):
        

        if is_float(key) and not self.is_floating():
            try:
                ckey = int(key)
                if ckey == key:
                    key = ckey
            except (OverflowError, ValueError, TypeError):
                pass
        return key
706817
def set_value_for_key(self, key, value):
        
        if key in self.options:
            self.options[key]['value'] = value
450033
function set (data, key, value) {
  if (Object(key) === key) {
    mix(data, key);
    return;
  }

  var keys = _keys(key);
  keys && _set(data, keys, value);
}
281791
def coerce(cls, key, value):
        
        if not isinstance(value, MutableList):
            if isinstance(value, list):
                return MutableList(value)
            # this call will raise ValueError
            return Mutable.coerce(key, value)
        else:
            return value
160928
def check_precondition(self, key, value):
        '''
        
        '''
        timeout = float(value)
        curr_time = self.get_current_time()
        if curr_time > timeout:
            return True
        return False
727710
def coerce(cls, key, value):
        ""

        if not isinstance(value, MutableDict):
            if isinstance(value, dict):
                return MutableDict(value)

            # this call will raise ValueError
            return Mutable.coerce(key, value)
        else:
            return value