:return: The current :class:`revision.data.Revision`.
        :rtype: :class:`revision.data.Revision`
484874
def current_revision(self):
        
        if self.current_index is None:
            return None

        if len(self.revisions) > self.current_index:
            return self.revisions[self.current_index]

        return None
516670
def v2010(self):
        
        if self._v2010 is None:
            self._v2010 = V2010(self)
        return self._v2010
90589
def __get_pending_revisions(self):
        
        dttime = time.mktime(datetime.datetime.now().timetuple())
        changes = yield self.revisions.find({
            "toa" : {
                "$lt" : dttime,
            },
            "processed": False,
            "inProcess": None
        })
        if len(changes) > 0:
            yield self.set_all_revisions_to_in_process([change.get("id") for change in changes])

        raise Return(changes)
309454
def save(self):
        

        # TODO: Add option force_insert

        if not self.is_loaded and self.id is None or self.id == '':
            data = self.resource.post(data=self.data, collection=self.collection)
            self.id = data['_id']
            self.key = data['_key']
            self.revision = data['_rev']
            self.is_loaded = True
        else:
            data = self.resource(self.id).patch(data=self.data)
            self.revision = data['_rev']
110629
def _get_revision(self, revision):
        

        if self._empty:
            raise EmptyRepositoryError("There are no changesets yet")

        if revision in [-1, 'tip', None]:
            revision = 'tip'

        try:
            revision = hex(self._repo.lookup(revision))
        except (IndexError, ValueError, RepoLookupError, TypeError):
            raise ChangesetDoesNotExistError("Revision %s does not "
                                    "exist for this repository"
                                    % (revision))
        return revision
458156
def get_current_data(self):
        """"""
        if self.current_imuid in self.calibration_data:
            return self.calibration_data[self.current_imuid]

        return {}
734608
def ver(self, revision):
        """"""

        c = self.clone()

        c.version = self._parse_version(self.version)

        return c
1099721
def get_revisions(page):
  
  start_string = "    <revision>\n"
  end_string = "    </revision>\n"
  ret = []
  current_pos = 0
  while True:
    start_pos = page.find(start_string, current_pos)
    if start_pos == -1:
      break
    end_pos = page.find(end_string, start_pos)
    assert end_pos != -1
    ret.append(page[start_pos + len(start_string):end_pos])
    current_pos = end_pos + len(end_string)
  return ret
1253351
def data(self):
        
        if self._next_update and datetime.now() > self._next_update:
            self.update()
        return self._data
801890
def _get_current_object(self):
        
        if not hasattr(self.__local, '__release_local__'):
            return self.__local()
        try:
            return getattr(self.__local, self.__name__)
        except AttributeError:
            raise RuntimeError('no object bound to %s' % self.__name__)
813880
def get_current_object(self):
        
        if not hasattr(self.__local, '__release_local__'):
            return self.__local()
        try:
            return getattr(self.__local, self.__name__)
        except AttributeError:
            raise RuntimeError('no object bound to %s' % self.__name__)
861742
async def get_current_position(self, refresh=True) -> dict:
        
        if refresh:
            await self.refresh()
        position = self._raw_data.get(ATTR_POSITION_DATA)
        return position
585788
def currentItem( self ):
        
        model = self.navigationModel()
        if ( not model ):
            return None
        
        return model.itemByPath(self.text())
674065
def read(self):
        

        if self._current >= len(self._data):
            return None
        self._current += 1
        return self._data[self._current - 1]
143392
def prepare_revision
      return if self.new_record?
      if (self.respond_to?(:blocks_attributes_changed) && self.blocks_attributes_changed) || 
        !(self.changed & revision_fields).empty?
        self.revision_data = revision_fields.inject({}) do |c, field|
          c[field] = self.send("#{field}_was")
          c
        end
      end
    end
960042
def current_revision
      @_current_revision ||= File.open(
        File.join(
          RackCommitStats.config.file_path_prefix, REVISION_LOG_FILE
        ), 'r'
      ).readlines.last.split
    end
863757
def data(self):
        
        return self.model.state.entity_data(
            self.entity_type, self.entity_id, self._history_index)