Mark the item as processed without download.
355566
def skip(self):
        ''''''
        _logger.debug(__(_('Skipping ‘{url}’.'), url=self.url_record.url))
        self.app_session.factory['URLTable'].check_in(self.url_record.url, Status.skipped)

        self._processed = True
272663
def _forget_page(self, page):
        """"""
        pid = id(page)
        if pid in self._page_refs:
            self._page_refs[pid] = None
703512
public final void clear() {
        items.clear();
        iconCount = 0;
        dividerCount = 0;

        if (rawItems != null) {
            rawItems.clear();
        }

        notifyOnDataSetChanged();
    }
138454
def idle_task(self):
        ''''''
        if self.download_last_timestamp is not None and time.time() - self.download_last_timestamp > 0.7:
            self.download_last_timestamp = time.time()
            self.handle_log_data_missing()
449255
def finish():
    """"""
    out.warn("Interrupted!")
    for t in threads:
        t.stop()
    jobs.clear()
    out.warn("Waiting for download threads to finish.")
5202
def delete_item(key):
    """"""
    CACHED_KEY_FILE = os.path.join(CURRENT_DIR, key)

    if os.path.isfile(CACHED_KEY_FILE):
        os.remove(CACHED_KEY_FILE)
754897
def DownloadProgressPrinter(response, unused_download):
    """"""
    if 'content-range' in response.info:
        print('Received %s' % response.info['content-range'])
    else:
        print('Received %d bytes' % response.length)
10899
def unpublish(self, path):
        """"""
        
        data = """
<propertyupdate xmlns="DAV:">
  <remove>
    <prop>
      <public_url xmlns="urn:yandex:disk:meta" />
    </prop>
  </remove>
</propertyupdate>
        """
        
        _check_dst_absolute(path)
        resp = self._sendRequest("PROPPATCH", addUrl=path, data=data)
        if resp.status_code == 207:
            pass
        else:
            raise YaDiskException(resp.status_code, resp.content)
590450
def delete(self, item, dry_run=None):
        """"""
        logger.debug('Deleting item. Item: {item} Path: {data_file}'.format(
            item=item,
            data_file=self.data_file
        ))

        items = load_file(self.data_file)
        items = remove_item(self.namespace, self.version, item, items)
        save_file(self.data_file, items, dry_run=dry_run)

        return item
836227
def remove(self, items):
        """"""
        with _presub_lock:
            self.load_from_cloud()
            for entry in utils.ensure_listable(items):
                # remove all matching entries
                while entry in self.current:
                    self.current.remove(entry)
            self.save_to_cloud()
274017
public synchronized void markNotReady() 
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "markNotReady");

    // No-op

    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "markNotReady");
  }
1010873
def load_bookmarks_without_file(filename):
    """"""
    bookmarks = _load_all_bookmarks()
    return {k: v for k, v in bookmarks.items() if v[0] != filename}
659133
def skip_all(self):
        """"""

        storage, streaming = self.engine.count()

        if self.selector.output:
            self.offset = streaming
        else:
            self.offset = storage

        self._count = 0
906554
def delete(self, item, dry_run=None):
        """"""
        return self.backend.delete(item, dry_run=dry_run)
662353
def skip_create(self, data, **kwargs):
        ""
        api_path = "/api/v2/skips.json"
        return self.call(api_path, method="POST", data=data, **kwargs)
1117726
def clear(self, exclude=None):
        
        if exclude is None:
            self.cache = {}
        else:
            self.cache = {k: v for k, v in self.cache.items()
                          if k in exclude}
654456
def clear(self):
        # type: () -> None
        """"""
        self._level = None
        self._fingerprint = None
        self._transaction = None
        self._user = None

        self._tags = {}  # type: Dict[str, Any]
        self._contexts = {}  # type: Dict[str, Dict]
        self._extras = {}  # type: Dict[str, Any]

        self.clear_breadcrumbs()
        self._should_capture = True

        self._span = None