Return the type.group.label dotted information
543152
def component_type(cls_or_slf, node):
        ""
        if node is None: return ''
        return cls_or_slf.type_formatter.format(type=str(type(node).__name__))
1203623
function labels (configName, callback) {

    if (callback) {
        return get(configName).schema.statics.getLabels(callback);
    }

    return get(configName).schema.statics.getLabels();
}
301193
def _GetDebuggeeDescription(self):
    """"""
    return '-'.join(self._debuggee_labels[label]
                    for label in _DESCRIPTION_LABELS
                    if label in self._debuggee_labels)
398691
def _sanitise_label_group(cls, labelgroup):
        

        if r'$\mid$' in labelgroup:
            label_components = labelgroup.split(r'$\mid$')
            good_labels = [l for l in
                           map(cls._sanitise_label, label_components)
                           if l is not None]
            if len(good_labels) == 0:
                return None
            else:
                return r'$\mid$'.join(good_labels)
        else:
            return cls._sanitise_label(labelgroup)
1037276
def labels(self):
        
        return [x for x in self[self.current_scope].values() if x.class_ == CLASS.label]
1314004
function getLabel (script) {
  let name = script.name
  if (script.isPre || script.isPost) {
    name = chalk.cyan(name)
  } else if (!script.isSub) {
    name = chalk.bold(name)
  }

  return name + chalk.dim(` — ${script.cmd}`)
}
833900
def dotted(self):
        """"""
        v = str(self.geoid.tract).zfill(6)
        return v[0:4] + '.' + v[4:]
960147
def _get_current_label(self):
        """"""
        if len(self._last) == 0:
            raise StopIteration
        return self._last[:self._last.find(":")]
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
405116
def indices(self):
        
        if len(self.groupings) == 1:
            return self.groupings[0].indices
        else:
            label_list = [ping.labels for ping in self.groupings]
            keys = [com.values_from_object(ping.group_index)
                    for ping in self.groupings]
            return get_indexer_dict(label_list, keys)
787529
def get_dotstr(self):
        """"""
        dotobj = self.gosubdagplot.get_pydot_graph() # pydot.Dot
        dotstr = dotobj.create_dot()
        return dotstr
1201039
def get_labels(cs):
    """"""
    records = []
    for c in cs:
        records.extend(c.get('labels', []))
    return records
201814
function graph (processedTypes, typeTheme) {
  var result = ''

  if (typeTheme.group) {
    result += 'subgraph cluster_' + groupId++ + ' {'
    if (typeTheme.color) {
      result += 'color=' + typeTheme.color + ';'
    }
    if (typeTheme.groupLabel) {
      result += 'label="' + typeTheme.groupLabel + '";'
    }
  }

  result += _.map(processedTypes, v => {
    // sort if desired
    if (this.theme.field.sort) {
      v.fields = _.sortBy(v.fields, 'name')
    }

    var rows = _.map(v.fields, v => {
      return {
        text: createField.call(this, v),
        port: v.name + 'port'
      }
    })

    return createTable.call(this, {
      typeName: getTypeDisplayName(v.name),
      color: typeTheme.color,
      stereotype: typeTheme.stereotype,
      rows: rows
    })
  }).join('\n')

  if (typeTheme.group) {
    result += '}'
  }

  result += '\n\n'
  return result
}
715992
def labels(self):
        
        if self._labels is None:
            self._labels = map(self.labelFormat().format, self.values())
        return self._labels
1299204
def dots(it, label="", hide=None, every=1):
    """"""
    count = 0
    if not hide:
        STREAM.write(label)
    for i, item in enumerate(it):
        if not hide:
            if i % every == 0:  # True every "every" updates
                STREAM.write(DOTS_CHAR)
                sys.stderr.flush()
        count += 1
        yield item

    STREAM.write("\n")
    STREAM.flush()
862451
def label(self):
        """"""
        if not self.desc:
            return "%.3fs" % self.timestamp
        return "%s (%.3fs)" % (self.desc, self.timestamp)
45846
def _type_string(label, case=None):
    """"""
    return label, abstractSearch.in_string, lambda s: abstractRender.default(s, case=case), ""