Return the last modification of the entry.
761002
def lastmod(self, tag):
        """"""
        lastitems = EntryModel.objects.published().order_by('-modification_date').filter(tags=tag).only('modification_date')
        return lastitems[0].modification_date
66270
def entry_modification_time(self):
    """"""
    timestamp = self._fsntfs_attribute.get_entry_modification_time_as_integer()
    return dfdatetime_filetime.Filetime(timestamp=timestamp)
33130
def last_revision(self, mod: YangIdentifier) -> ModuleId:
        
        revs = [mn for mn in self.modules if mn[0] == mod]
        if not revs:
            raise ModuleNotRegistered(mod)
        return sorted(revs, key=lambda x: x[1])[-1]
1308123
private function getActualLastModifiedTime()
    {
        if (empty($this->objectList)) return;

        foreach ($this->objectList as $object) {
            $modifiedTime = $object->getLastModifiedTimestamp();

            if (!empty($modifiedTime) && $modifiedTime > $this->lastModifiedTime) {
                $this->lastModifiedTime = $modifiedTime;
            }
        }
    }
675100
public function lastKey()
    {
        $keys = AccessHelper::collectionKeys($this->data);

        if (empty($keys) || end($keys) === false) {
            return null;
        }

        return end($keys);
    }
671799
def correct_entry(self, entry):
        
        entry.correction.update(self.get_correction(entry))
        return entry
179728
def last_update_time(self) -> float:
        """"""
        stdout = self.stdout_interceptor
        stderr = self.stderr_interceptor

        return max([
            self._last_update_time,
            stdout.last_write_time if stdout else 0,
            stderr.last_write_time if stderr else 0,
        ])
569030
def do_last(environment, seq):
    """"""
    try:
        return next(iter(reversed(seq)))
    except StopIteration:
        return environment.undefined('No last item, sequence was empty.')
307400
def last_modified(self) -> Optional[datetime.datetime]:
        
        httpdate = self._headers.get(hdrs.LAST_MODIFIED)
        if httpdate is not None:
            timetuple = parsedate(httpdate)
            if timetuple is not None:
                return datetime.datetime(*timetuple[:6],
                                         tzinfo=datetime.timezone.utc)
        return None
1044788
def remove_last_entry(self):
        """"""
        self.current_beat -= 1.0 / self.bar[-1][1]
        self.bar = self.bar[:-1]
        return self.current_beat
303788
def last_updated(self):
        '''
        
        '''
        derived_path = self.context.request.url
        timestamp_key = self.timestamp_key_for(derived_path)

        if self.exists(self.timestamp_key_for, derived_path):
            return self.storage.get(timestamp_key)

        return None
742672
def last_modified_time(path):
    
    return pd.Timestamp(os.path.getmtime(path), unit='s', tz='UTC')
212343
def last_seen(self):
        """
        These values seem to be rarely updated correctly in the API.
        Don't expect accurate results from this property.
        """
        try:
            if self.side == 'left':
                lastseen = self.device.device_data['leftPresenceEnd']
            elif self.side == 'right':
                lastseen = self.device.device_data['rightPresenceEnd']

            date = datetime.fromtimestamp(int(lastseen)) \
                .strftime('%Y-%m-%dT%H:%M:%S')
            return date
        except TypeError:
            return None
877923
def modified_on(self):
    """"""
    timestamp = self._info.get('lastModifiedTime')
    return _parser.Parser.parse_timestamp(timestamp)
1273906
def last(self):
        
        if self.type == HoloMap:
            last_items = [(k, v.last if isinstance(v, HoloMap) else v)
                          for (k, v) in self.data.items()]
        else:
            last_items = self.data
        return self.clone(last_items)
184057
def get_last_modified_date(*args, **kwargs):
    
    try:
        latest_note = Note.objects.latest()
        latest_release = Release.objects.latest()
    except ObjectDoesNotExist:
        return None

    return max(latest_note.modified, latest_release.modified)
1335471
@Override
	public long getLastModified(String filePath) {
		long lastModified = 0;
		File f = new File(filePath);
		if (f.exists()) {
			lastModified = f.lastModified();
		}
		return lastModified;
	}