Remove an annot from reference dictionary.
489093
def _forget_annot(self, annot):
        """"""
        aid = id(annot)
        if aid in self._annot_refs:
            self._annot_refs[aid] = None
1038199
function truncateAnnotation (tx, anno, sel) {
  if (!sel || !sel._isSelection) throw new Error('Argument "selection" is required.')
  if (!anno || !anno.isAnnotation()) throw new Error('Argument "anno" is required and must be an annotation.')
  let annoSel = anno.getSelection()
  let newAnnoSel = annoSel.truncateWith(sel)
  anno._updateRange(tx, newAnnoSel)
  return anno
}
197065
def remove_context(self, name):
        
        self._context(name)
        del self.contexts[name]
        self._flush_tools()
1200713
def remove_annotation_value(graph, annotation, value):
    
    if annotation not in graph.defined_annotation_keywords:
        log.warning('annotation was not defined: %s', annotation)
        return

    for u, v, k in graph.edges(keys=True):
        if ANNOTATIONS not in graph[u][v][k]:
            continue

        if annotation not in graph[u][v][k][ANNOTATIONS]:
            continue

        if value not in graph[u][v][k][ANNOTATIONS][annotation]:
            continue

        del graph[u][v][k][ANNOTATIONS][annotation][value]
1046154
def remove_None(params: dict):
    """"""
    return {
        key: value
        for key, value in params.items()
        if value is not None
    }
885344
def remove_by(keys, original):
    """"""
    for i in [
            original[index]
            for index, needed in enumerate(keys) if not needed
    ]:
        original.remove(i)
530640
def clear(name):
    '''
    
    '''
    ret = {'name': name,
           'changes': {},
           'comment': '',
           'result': True}
    if name in __reg__:
        __reg__[name].clear()
    return ret
622114
def removeUnreferencedIDs(referencedIDs, identifiedElements):
    
    global _num_ids_removed
    keepTags = ['font']
    num = 0
    for id in identifiedElements:
        node = identifiedElements[id]
        if id not in referencedIDs and node.nodeName not in keepTags:
            node.removeAttribute('id')
            _num_ids_removed += 1
            num += 1
    return num
275730
def remove(self, cls, originalMemberNameList, memberName, classNamingConvention):
        
        accessorDict = self._accessorDict(memberName, classNamingConvention)
        for accessorName, _ in accessorDict.items():
            if accessorName not in originalMemberNameList and hasattr(cls, accessorName):
                delattr(cls, accessorName)
475417
def cleanup(self):
        
        for dict in (self.rule2func, self.rules, self.rule2name):
            for i in list(dict.keys()):
                dict[i] = None
        for i in dir(self):
            setattr(self, i, None)
47803
def clear(self):
        """"""
        self.statement_group = None
        self.citation.clear()
        self.evidence = None
        self.annotations.clear()
1083381
def remove(self, ref, cb=None):
        """"""

        if self.is_api:
            return self._remove_api(ref, cb)
        else:
            return self._remove_fs(ref, cb)
630189
function removeReference(name, opposite) {
  const ref = this.references[name]
  _.unset(this.references, name)
  if (ref.opposite !== undefined) {
    if (opposite) {
      _.unset(ref.type.references, ref.opposite)
    } else {
      _.unset(ref.type.references[ref.opposite], 'opposite')
    }
  }
}
768830
def deleteAnnot(self, fannot):
        """"""
        CheckParent(self)

        val = _fitz.Page_deleteAnnot(self, fannot)
        if val:
            val.thisown = True
            val.parent = weakref.proxy(self) # owning page object
            val.parent._annot_refs[id(val)] = val
        fannot._erase()


        return val
384109
def remove(client, name):
    """"""
    from renku.models.refs import LinkReference
    LinkReference(client=client, name=_ref(name)).delete()
729674
def remove(self, annotation):
        
        if annotation.id in self._annotations:
            del self._annotations[annotation.id]
        self._dirty = True
856748
def unlink(self, func):
        '''
        

        '''
        if func in self._syn_links:
            self._syn_links.remove(func)