Converts map element into a Date or returns None if conversion is not possible.

        :param key: an index of element to get.

        :return: Date value of the element or None if conversion is not supported.
334919
def get_as_nullable_datetime(self, key):
        
        value = self.get(key)
        return DateTimeConverter.to_nullable_datetime(value)
721003
def mtime(self, key):
        """"""
        if key not in self.__dict:
            raise CacheKeyError(key)
        else:
            node = self.__dict[key]
            return node.mtime
324335
@Nullable
    public static Date getDate(@NonNull SharedPreferences prefs, @NonNull String key) {
        long time = prefs.getLong(key, Long.MIN_VALUE);
        return time == Long.MIN_VALUE ? null : new Date(time);
    }
539801
def valid_date(key, config_date):
    
    key_date = "/".join(key.split("/")[4:7])
    return parse_date(key_date) > parse_date(config_date)
738358
def get(self, key):
        

        if isinstance(key, tuple):
            # TODO handle different ordering
            try:
                x, y = float(key[0]), float(key[1])
            except IndexError:
                raise ValueError("Two values are required for a coordinate pair")

            except ValueError:
                raise ValueError("Only float or float-coercable values can be passed")

            key = "{0},{1}".format(x, y)

        return self[self.lookups[key]]
1300165
public ZonedDateTime getAsNullableDateTime(String key) {
		Object value = getAsObject(key);
		return DateTimeConverter.toNullableDateTime(value);
	}
371642
def get_index(self, key):
        
        try:
            return self[self.index_lookup.get(key)]

        except TypeError:
            raise KeyError
599354
function(key) {

            // get value and time left
            var ret = {
                value: this._storage.getItem(key),
                timeLeft: this.getTimeLeft(key),
            };

            // set if expired
            ret.isExpired = ret.timeLeft !== null && ret.timeLeft <= 0;

            // return data
            return ret;
        }
727221
def validate_iso_date key, value, opts
      if opts[:iso_date]
        return value.strftime("%Y-%m-%d")  if value.respond_to?(:strftime)
      end
      value
    end
950583
def get(self, key, _else=None):
        
        with self._lock:
            self.expired()
            # see if everything expired
            try:
                value = self._dict[key].get()
                return value
            except KeyError:
                return _else
            except ValueError:
                return _else
1231580
def get_as_array(self, key):
        
        value = self.get(key)
        return AnyValueMap.from_value(value)
1227501
def get_as_nullable_string(self, key):
        
        value = self.get(key)
        return StringConverter.to_nullable_string(value)
1116238
def _get_payload(self, key):
        
        payload = self._storage.get(key)

        # If the key does not exist, we return nothing
        if not payload:
            return (None, None)

        expire = payload[0]

        # If the current time is greater than expiration timestamps we will delete
        # the entry
        if round(time.time()) >= expire:
            self.forget(key)

            return (None, None)

        data = payload[1]

        # Next, we'll extract the number of minutes that are remaining for a cache
        # so that we can properly retain the time for things like the increment
        # operation that may be performed on the cache. We'll round this out.
        time_ = math.ceil((expire - round(time.time())) / 60.)

        return (data, time_)
309361
public static Date getDate(JSONObject json, String key) {
        return getDate(json, key, null);
    }
82566
def get(self, key):
        

        if not self.is_loaded:
            self.retrieve()

            self.is_loaded = True

        if self.has(key=key):
            return self.data[key]
        else:
            return None
633456
def _get_time(header, keys, name):
        
        for key in keys:
            try:
                date_value = header.pop(key)
            except KeyError:
                continue
            try:
                # String to convert
                return to_timestamp(parse(date_value))
            except TypeError:
                # Already number
                return float(date_value)
        raise UnsupportedOperation(name)
313885
def then_the_return_element_have_no_key(context, line, key):
    
    line = int(line)
    data = context.apiRequest.data
    assert 0 <= line < len(data)
    assert key not in data[line]