Executor for `globus bookmark delete`
499785
def bookmark_delete(bookmark_id_or_name):
    
    client = get_client()
    bookmark_id = resolve_id_or_name(client, bookmark_id_or_name)["id"]

    res = client.delete_bookmark(bookmark_id)
    formatted_print(res, text_format=FORMAT_TEXT_RAW, response_key="message")
258544
static function deleteBookObjectCache() {

		global $blog_id;

		// Book Object
		wp_cache_delete( "book-inf-$blog_id", 'pb' ); // Delete the cached value for getBookInfo()
		wp_cache_delete( "book-str-$blog_id", 'pb' ); // Delete the cached value for getBookStructure()
		wp_cache_delete( "book-cnt-$blog_id", 'pb' ); // Delete the cached value for getBookContents()
		static::$__order = [];

		// Subsections
		delete_transient( static::SUBSECTIONS_TRANSIENT );

		// User Catalog
		( new Catalog() )->deleteCacheByBookId( $blog_id );

		// Output buffers
		delete_transient( Xhtml11::TRANSIENT );

		/**
		 * @since 5.0.0
		 *
		 * @param int $blog_id
		 */
		do_action( 'pb_cache_delete', $blog_id );
		set_transient( 'pb_cache_deleted', time(), DAY_IN_SECONDS );
	}
1281457
public BoxRequestsBookmark.DeleteBookmark getDeleteRequest(String id) {
        BoxRequestsBookmark.DeleteBookmark request = new BoxRequestsBookmark.DeleteBookmark(id, getBookmarkInfoUrl(id), mSession);
        return request;
    }
1232177
synchronized void cleanUp() {

        updateAccessCounts();

        int                          removeCount = size() / 2;
        int accessTarget = getAccessCountCeiling(removeCount, removeCount / 8);
        BaseHashMap.BaseHashIterator it          = new BaseHashIterator();
        int                          savecount   = 0;

        for (; it.hasNext(); ) {
            CachedObject r = (CachedObject) it.next();

            if (it.getAccessCount() <= accessTarget) {
                synchronized (r) {
                    if (!r.isKeepInMemory()) {
                        r.setInMemory(false);

                        if (r.hasChanged()) {
                            rowTable[savecount++] = r;
                        }

                        it.remove();

                        cacheBytesLength -= r.getStorageSize();

                        removeCount--;
                    }
                }
            }
        }

        if (removeCount > 50) {
            it = new BaseHashIterator();

            for (; removeCount >= 0 && it.hasNext(); ) {
                CachedObject r = (CachedObject) it.next();

                if (!r.isKeepInMemory()) {
                    r.setInMemory(false);

                    if (r.hasChanged()) {
                        rowTable[savecount++] = r;
                    }

                    it.remove();

                    cacheBytesLength -= r.getStorageSize();

                    removeCount--;
                }
            }
        }

        super.setAccessCountFloor(accessTarget);
        saveRows(savecount);
    }
1051431
public void free()
    {
        m_bookmark = null;
        m_objectID = null;
        m_dataSource = null;
        m_objectSource = null;
        if (m_buffer != null)
        {
            m_buffer.free();
            m_buffer = null;
        } 
    }
1270476
def _cleanup_markers(context_id, task_ids):
    """"""

    logging.debug("Cleanup %d markers for Context %s",
                  len(task_ids), context_id)

    # TODO: Handle exceptions and retries here.
    delete_entities = [ndb.Key(FuriousAsyncMarker, id) for id in task_ids]
    delete_entities.append(ndb.Key(FuriousCompletionMarker, context_id))

    ndb.delete_multi(delete_entities)

    logging.debug("Markers cleaned.")
1026251
def remove_bookmark(self, time):
        
        self.annot.remove_bookmark(time=time)
        self.update_annotations()
665975
function (node) {
        var recMarker = jsonUtils.TEMP_REC_MARKER;
        if (node[recMarker]) {
            node[recMarker] = false;
            delete node[recMarker];
            var parents = node[jsonUtils.OBJECT_PARENT_PROPERTY];
            if (parents) {
                for (var index = 0, l = parents.length; index < l; index++) {
                    __cleanUpRecMarkers(parents[index].parent);
                }
            }
        }
    }
993288
def clean(docs=False, bytecode=False, extra=''):
    ''''''
    patterns = ['build', 'dist', 'cover', 'docs/_build', '**/*.pyc', '*.egg-info', '.tox', '**/__pycache__']
    for pattern in patterns:
        print('Removing {0}'.format(pattern))
        lrun('rm -rf {0}'.format(pattern))
459698
def query_delete(query)
      @dir.synchronize do
        ensure_writer_open()
        ensure_searcher_open()
        query = do_process_query(query)
        @searcher.search_each(query, :limit => :all) do |doc, score|
          @reader.delete(doc)
        end
        flush() if @auto_flush
      end
    end
1082379
def save_bookmarks(filename, bookmarks):
    """"""
    if not osp.isfile(filename):
        return
    slots = load_bookmarks_without_file(filename)
    for slot_num, content in bookmarks.items():
        slots[slot_num] = [filename, content[0], content[1]]
    CONF.set('editor', 'bookmarks', slots)
438391
def __delete_internal_blob(self, key):
        ''' 
        '''
        with self.get_conn() as conn:
            conn.isolation_level = None
            try:
                c = conn.cursor()
                c.execute("BEGIN")
                if key is None:
                    c.execute("DELETE FROM cache_entries WHERE key IS NULL")
                    c.execute("DELETE FROM blob_entries WHERE KEY IS NULL")
                else:
                    c.execute("DELETE FROM cache_entries WHERE key = ?", (key,))
                    c.execute("DELETE FROM blob_entries WHERE KEY = ?", (key,))
                c.execute("COMMIT")
            except:
                getLogger().debug("Cannot delete")
                return False
            return True
107548
public void deleteBulkDocsAsync(String index, String type) {
        executeBulkRequestAsync(buildDeleteBulkRequestBuilder(
                buildAllDeleteRequestBuilderList(index, type)));
    }
16605
public ProcedureRunner getNibbleDeleteProc(String procName,
                                               Table catTable,
                                               Column column,
                                               ComparisonOperation op)
    {
        ProcedureRunner pr = m_defaultProcCache.get(procName);
        if (pr == null) {
            Procedure newCatProc =
                    StatementCompiler.compileNibbleDeleteProcedure(
                            catTable, procName, column, op);
            VoltProcedure voltProc = new ProcedureRunner.StmtProcedure();
            pr = new ProcedureRunner(voltProc, m_site, newCatProc);
            // this will ensure any created fragment tasks know to load the plans
            // for this plan-on-the-fly procedure
            pr.setProcNameToLoadForFragmentTasks(newCatProc.getTypeName());
            m_defaultProcCache.put(procName, pr);
            // also list nibble delete into default procedures
            m_defaultProcManager.m_defaultProcMap.put(procName.toLowerCase(), pr.getCatalogProcedure());
        }
        return pr;
    }
383665
public Object doSetHandle(Object bookmark, int iOpenMode, String strFields, int iHandleType) throws DBException, RemoteException
    {
        return this.seek(null, 0, null, strFields, bookmark);
    }
687879
function cleanMarks( o ) {
        delete o[randKey];

        for ( prop in o ) {
            if ( p.hasOwnProperty( prop )
                    && get_type( p[prop] ) == 'object'
                    && randKey in p[prop]) {
               cleanMarks( p[prop] );
            }
        }
    }
340736
function (options, deleteBatch, callbacky) {
  var numberDocsToDelete = 0
  if (!Array.isArray(deleteBatch)) {
    deleteBatch = [deleteBatch]
  }
  a.series([
    function(callback) {
      if (!options.deletable) {
        options.indexes.get('DF￮*￮*￮￮', function (err, keys) {
          // are any of the deletebatch in the index?
          var keysInIndex = _intersection(deleteBatch, keys)
          var docExistsErr = null
          if (keysInIndex.length > 0) {
            docExistsErr = new Error(
              'this index is non-deleteable, and some of the documents you are deleting have IDs that are already present in the index. Either reinitialize index with "deletable: true" or alter the IDs of the new documents')
            return callbacky(docExistsErr)
          } else {
            return callback(null, null)
          }
        })
      } else {
        return callback(null, null)
      }
    },
    function(callback) {
      a.mapLimit(deleteBatch, 5, function (docID, mapCallback) {
        options.indexes.get('DELETE-DOCUMENT￮' + docID, function (err, keys) {
          if (err) {
            if (err.name === 'NotFoundError') {
              return mapCallback(null, [])
            }
          } else {
            numberDocsToDelete++
          }
          return mapCallback(err, keys)
        })
      }, function (err, results) {
        if (err) {
          return callbacky(err)
        } else {
          deleteThisBatch(options, numberDocsToDelete, deleteBatch, results, function (err) {
            return callbacky(err)
          })
        }
      })
    }
  ])

}