Returns the rows in InterLex associated with that label

        Note:
            Pressumed to have duplicated labels in InterLex
        Args:
            label: label of the entity you want to find
        Returns:
            None or List[dict]
551016
def label_search(self, label:str) -> List[dict]:
        ''' 
        '''
        ilx_rows = self.label2rows(self.local_degrade(label))
        if not ilx_rows:
            return None
        else:
            return ilx_rows
1362473
def _get_elements(mol, label):
        
        elements = [int(mol.GetAtom(i).GetAtomicNum()) for i in label]
        return elements
1037276
def labels(self):
        
        return [x for x in self[self.current_scope].values() if x.class_ == CLASS.label]
504579
def labels_to_indices(self, labels: Sequence[str]) -> List[int]:
        

        return [self.LABEL_TO_INDEX[label] for label in labels]
690103
def get_label(self):
        
        if self.label is None:
            self.label = self.get_field('label')
        return self.label
1305847
def get_labels(labels):
    """"""
    label_u = unique_labels(labels)
    label_u_line = [i + "_line" for i in label_u]
    return label_u, label_u_line
1218119
def guess_labels(self, doc):
        
        doc = doc.clone()  # make sure it can be serialized safely
        return self.index.guess_labels(doc)
620055
def getLabel(self):
        
        response = xmlparser(
            self.retriever.getLabel(urn=str(self.urn))
        )

        self._parse_request(
            response.xpath("//ti:reply/ti:label", namespaces=XPATH_NAMESPACES)[0]
        )

        return self.metadata
625287
def label(self, id):
        
        if self.ontology is not None:
            label = self.ontology.label(id)
            if label is not None:
                return label
        if self.subject_label_map is not None and id in self.subject_label_map:
            return self.subject_label_map[id]
        return None
766360
def label(labelname)
      read_labels
      return [nil, nil, nil] if @label.size < 1 || !@label.key?(labelname)
      [
        @label[labelname][1].to_i,
        ::Roo::Utils.letter_to_number(@label[labelname][2]),
        @label[labelname][0]
      ]
    end
1035563
def get_labels(self):
        
        return github.PaginatedList.PaginatedList(
            github.Label.Label,
            self._requester,
            self.issue_url + "/labels",
            None
        )
733843
def get_next(self, label):
        """"""
        while self._get_current_label() != label:
            self._skip_section()
        return self._read_section()
1075402
def process_synonyms(self, entity: List[dict]) -> List[dict]:
        
        label = entity['label']
        for synonym in entity['synonyms']:
            # these are internal errors and users should never see them
            if 'literal' not in synonym:
                raise ValueError(f'Synonym not given a literal for label: {label}')
            elif len(synonym) > 1:
                raise ValueError(f'Too many keys in synonym for label: {label}')
        return entity
896880
def make_indices_to_labels(labels: Set[str]) -> Dict[int, str]:
    

    return {index: label for index, label in
            enumerate(["pad"] + sorted(list(labels)))}
1123552
def _get_column(self, column_or_label):
        """"""
        c = column_or_label
        if isinstance(c, collections.Hashable) and c in self.labels:
            return self[c]
        elif isinstance(c, numbers.Integral):
            return self[c]
        elif isinstance(c, str):
            raise ValueError('label "{}" not in labels {}'.format(c, self.labels))
        else:
            assert len(c) == self.num_rows, 'column length mismatch'
            return c
284065
def get_label_fields(self):
        
        present_label_fields = []
        for field in ann_label_fields:
            if getattr(self, field) is not None:
                present_label_fields.append(field)

        return present_label_fields
303205
def by_label(self, label):
        """"""
        # don't use .first(), so that MultipleResultsFound can be raised
        try:
            return self.filter_by(label=label).one()
        except sa.orm.exc.NoResultFound:
            return None