Set self._sink_scc_labels, which is a list containing the labels of
        the strongly connected components.
514371
def _find_sink_scc(self):
        
        condensation_lil = self._condensation_lil()

        # A sink SCC is a SCC such that none of its members is strongly
        # connected to nodes in other SCCs
        # Those k's such that graph_condensed_lil.rows[k] == []
        self._sink_scc_labels = \
            np.where(np.logical_not(condensation_lil.rows))[0]
482125
def create_chan_labels(self):
        
        self.idx_label = []
        for one_grp in self.parent.channels.groups:
            for one_label in one_grp['chan_to_plot']:
                item = QGraphicsSimpleTextItem(one_label)
                item.setBrush(QBrush(QColor(one_grp['color'])))
                item.setFlag(QGraphicsItem.ItemIgnoresTransformations)
                self.idx_label.append(item)
36023
def modSymbolsFromLabelInfo(labelDescriptor):
    
    modSymbols = set()
    for labelStateEntry in viewvalues(labelDescriptor.labels):
        for labelPositionEntry in viewvalues(labelStateEntry['aminoAcidLabels']):
            for modSymbol in aux.toList(labelPositionEntry):
                if modSymbol != '':
                    modSymbols.add(modSymbol)
    return modSymbols
576105
def _label_from_list(self, labels:Iterator, label_cls:Callable=None, from_item_lists:bool=False, **kwargs)->'LabelList':
        ""
        if not from_item_lists:
            raise Exception("Your data isn't split, if you don't want a validation set, please use `split_none`.")
        labels = array(labels, dtype=object)
        label_cls = self.get_label_cls(labels, label_cls=label_cls, **kwargs)
        y = label_cls(labels, path=self.path, **kwargs)
        res = self._label_list(x=self, y=y)
        return res
222745
def wanted_labels(self, labels):
        
        if not isinstance(labels, list):
            raise ValueError("Input labels must be a list.")

        self.user_labels = labels
1209035
def set_state(self, value, labels=None):
        

        values = {"value": value}
        json_labels = []
        if labels:
            for label in labels:
                json_labels.append(str(label).upper())
            values["labels"] = json_labels

        self._update_state_from_response(self.parent.set_dial(values, self.index()))
150685
public void setLWMScn(String source, long scn) {
        WaterMarkEntry e = sourceWaterMarkMap.get(source);
        if (e == null) {
            e = new WaterMarkEntry(source);
            sourceWaterMarkMap.put(source, e);
        }
        e.setLWMScn(scn);
    }
857750
def node_labels(self):
        """"""
        assert list(self.node_indices)[0] == 0
        labels = list("m{}".format(i) for i in self.node_indices)
        return NodeLabels(labels, self.node_indices)
424067
public void resetLabels() {
        AbstractInsnNode insn = first;
        while (insn != null) {
            if (insn instanceof LabelNode) {
                ((LabelNode) insn).resetLabel();
            }
            insn = insn.next;
        }
    }
1305407
def source_components(self):
        
        raw_sccs = self._component_graph()

        # Construct a dictionary mapping each vertex to the root of its scc.
        vertex_to_root = self.vertex_dict()

        # And keep track of which SCCs have incoming edges.
        non_sources = self.vertex_set()

        # Build maps from vertices to roots, and identify the sccs that *are*
        # reachable from other components.
        for scc in raw_sccs:
            root = scc[0][1]
            for item_type, w in scc:
                if item_type == 'VERTEX':
                    vertex_to_root[w] = root
                elif item_type == 'EDGE':
                    non_sources.add(vertex_to_root[w])

        sccs = []
        for raw_scc in raw_sccs:
            root = raw_scc[0][1]
            if root not in non_sources:
                sccs.append([v for vtype, v in raw_scc if vtype == 'VERTEX'])

        return [self.full_subgraph(scc) for scc in sccs]
88441
def labels(indices, node_labels=None):
    """"""
    if node_labels is None:
        return tuple(map(str, indices))
    return node_labels.indices2labels(indices)
698959
def label_set(self):
        """"""
        label_set = list()
        for class_ in self.class_set:
            samples_in_class = self.sample_ids_in_class(class_)
            label_set.append(self.labels[samples_in_class[0]])

        return label_set
609486
public void setListLabels(String chosenLabel, String sourceLabel) {
        if (chosenLabel != null) {
            this.chosenLabel.setText(chosenLabel);
            this.chosenLabel.setVisible(true);
        } else {
            this.chosenLabel.setVisible(false);
        }

        if (sourceLabel != null) {
            this.sourceLabel.setText(sourceLabel);
            this.sourceLabel.setVisible(true);
        } else {
            this.sourceLabel.setVisible(false);
        }

        Dimension d = chosenList.getPreferredSize();
        Dimension d1 = this.chosenLabel.getPreferredSize();
        Dimension dChosenPanel = chosenPanel.getPreferredSize();

        dChosenPanel.width = Math.max(d.width, Math.max(dChosenPanel.width, d1.width));
        chosenPanel.setPreferredSize(dChosenPanel);

        Dimension dSourceList = sourceList.getPreferredSize();
        Dimension dSource = this.sourceLabel.getPreferredSize();
        Dimension dSourcePanel = sourcePanel.getPreferredSize();
        dSourcePanel.width = Math.max(dSource.width, Math.max(dSourceList.width, dSourcePanel.width));
        sourcePanel.setPreferredSize(dSourcePanel);

        Dimension fullPanelSize = getPreferredSize();
        fullPanelSize.width =
                dSourcePanel.width + dChosenPanel.width + (editButton != null ? editButton.getPreferredSize().width : 0)
                        + (buttonPanel != null ? buttonPanel.getPreferredSize().width : 0) + 20;
        setPreferredSize(fullPanelSize);
    }
165174
def set_labels(self, labels, axis='rows'):
        '''
        
        '''
        if axis.lower() in ('rows', 'row', 'r', 0):
            assigned_pos = set(v[0] for v in self._positions.itervalues())
            not_assigned = set(labels) - assigned_pos
            if len(not_assigned) > 0:
                msg = 'New labels must contain all assigned positions'
                raise ValueError(msg)
            self.row_labels = labels
        elif axis.lower() in ('cols', 'col', 'c', 1):
            self.col_labels = labels
        else:
            raise TypeError('Unsupported axis value %s' % axis)
518277
def build(self):
        """"""

        assert not self.final, 'Trying to mutate a final graph.'

        # Replace each strongly connected component with a single node `NodeSet`
        for scc in sorted(nx.kosaraju_strongly_connected_components(self.graph),
                          key=len, reverse=True):
            if len(scc) == 1:
                break

            self.shrink_to_node(NodeSet(scc))

        self.final = True
66284
public void setSinks(java.util.Collection<CatalogEntry> sinks) {
        if (sinks == null) {
            this.sinks = null;
            return;
        }

        this.sinks = new java.util.ArrayList<CatalogEntry>(sinks);
    }
815656
def _labels_from_pyclusters(self):
        
        clusters = self.model.get_clusters()
        labels = []
        for i in range(0, len(clusters)):
            for j in clusters[i]:
                labels.insert(int(j), i)
        return labels