Returns a string summarizing the parameter. Format is:
        <prefix>``name`` : {``default``, ``dtype``}
        <prefix>   ``description`` Label: ``label``.
967428
def docstr(self, prefix='', include_label=True):
        
        outstr = "%s%s : {%s, %s}\n" %(prefix, self.name, str(self.default),
            str(self.dtype).replace("<type '", '').replace("'>", '')) + \
            "%s    %s" %(prefix, self.description)
        if include_label:
            outstr += " Label: %s" %(self.label)
        return outstr
1128196
def create_scalar_summary(name, v):
    
    assert isinstance(name, six.string_types), type(name)
    v = float(v)
    s = tf.Summary()
    s.value.add(tag=name, simple_value=v)
    return s
1319941
public String getDescription(int numDigits) {
    StringBuffer sb = new StringBuffer();
    sb.append("--- PR Stats ---").append("\n");
    for (L label : labelIndex) {
      if (label.equals(negLabel)) { continue; }      
      sb.append("** ").append(label.toString()).append(" **\n");
      sb.append("\tPrec:   ").append(getPrecisionDescription(numDigits, label)).append("\n");
      sb.append("\tRecall: ").append(getRecallDescription(numDigits, label)).append("\n");
      sb.append("\tF1:     ").append(getF1Description(numDigits, label)).append("\n");
    }
    sb.append("** Overall **\n");
    sb.append("\tPrec:   ").append(getPrecisionDescription(numDigits)).append("\n");
    sb.append("\tRecall: ").append(getRecallDescription(numDigits)).append("\n");
    sb.append("\tF1:     ").append(getF1Description(numDigits));
    return sb.toString();
  }
1300047
def getNamedItem(self, name: str) -> Optional[Attr]:
        
        return self._dict.get(name, None)
957849
def summary(self, name=None):
        
        warnings.warn("'summary' is deprecated and will be removed in a "
                      "future version.", FutureWarning, stacklevel=2)
        return self._summary(name)
788042
def info(self):
        
        if (len(self.values()) > 0):
            info_str = self.__class__.__name__ +\
                       " containing %d items of type %s\n" % (len(self.keys()),
                                                              type(self.values()[0]).__name__)
        else:
            info_str = self.__class__.__name__ + " containing no items\n"
        info_str += ('-' * (len(info_str)-1)) + "\n\n"
        aliases = {v: k for k, v in self._dim_aliases.items()}
        for group in self._dim_groups:
            dimensions = getattr(self, group)
            if dimensions:
                group = aliases[group].split('_')[0]
                info_str += '%s Dimensions: \n' % group.capitalize()
            for d in dimensions:
                dmin, dmax = self.range(d.name)
                if d.value_format:
                    dmin, dmax = d.value_format(dmin), d.value_format(dmax)
                info_str += '\t %s: %s...%s \n' % (d.pprint_label, dmin, dmax)
        print(info_str)
756159
def format_param(p):
    ""
    arg_prefix = arg_prefixes.get(p.kind, '') # asterisk prefix for *args and **kwargs
    res = f"**{arg_prefix}{code_esc(p.name)}**"
    if hasattr(p, 'annotation') and p.annotation != p.empty: res += f':{anno_repr(p.annotation)}'
    if p.default != p.empty:
        default = getattr(p.default, 'func', p.default)
        default = getattr(default, '__name__', default)
        res += f'=***`{repr(default)}`***'
    return res
145451
def get_label(self, name):
        
        assert isinstance(name, (str, unicode)), name
        headers, data = self._requester.requestJsonAndCheck(
            "GET",
            self.url + "/labels/" + urllib.quote(name)
        )
        return github.Label.Label(self._requester, headers, data, completed=True)
355753
def label(self, name, internal=False, definition=False):
        
        return "{0}{1}{2}".format(self.internal if internal else "", name, self.definition if definition else "")
818832
def get_spacer_label(self):
        

        spacer = QLabel()
        spacer.setObjectName("Spacer_label")
        spacer.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
        return spacer
988338
def prefixedname_to_str(self, prefix: ShExDocParser.PrefixedNameContext) -> str:
        
        if prefix.PNAME_NS():
            return self._lookup_prefix(prefix.PNAME_NS().getText())
        else:
            prefix, local = prefix.PNAME_LN().getText().split(':', 1)
            return self._lookup_prefix(prefix + ':') + (local if local else "")
429837
def GetSeverityString(self, severity):
    
    if 0 <= severity < len(self._SEVERITY):
      return self._SEVERITY[severity]
    return 'Unknown {0:d}'.format(severity)
554951
def _repr_label_vector(self, label_vector):
        

        string = ["1"]
        for cross_terms in label_vector:
            sub_string = []
            for index, order in cross_terms:
                _ = self.grid_points.dtype.names[index]
                if order > 1:
                    sub_string.append("{0}^{1}".format(_, order))
                else:
                    sub_string.append(_)
            string.append(" * ".join(sub_string))
        return " + ".join(string)
285380
def get_label(self, label, params=None):
        
        return self.label(label, action='GET', params=params)
793606
def _format_data(self, name=None):
        

        # do we want to justify (only do so for non-objects)
        is_justify = not (self.inferred_type in ('string', 'unicode') or
                          (self.inferred_type == 'categorical' and
                           is_object_dtype(self.categories)))

        return format_object_summary(self, self._formatter_func,
                                     is_justify=is_justify, name=name)
791980
def summary(self):
    
    with tf.name_scope(self._name + '/summary'):
      mean_summary = tf.cond(
          self._count > 0, lambda: self._summary('mean', self._mean), str)
      std_summary = tf.cond(
          self._count > 1, lambda: self._summary('stddev', self._std()), str)
      return tf.summary.merge([mean_summary, std_summary])
1325980
public String getDescriptionForParameter(String name) {
    if (documentation == null || documentation.parameters == null) {
      return null;
    }

    return documentation.parameters.get(name);
  }