The label of the field, including indicators.
511427
function FieldLabel(props) {
    var label = props.label, indicator = props.indicator, tooltipProps = props.tooltipProps, infoIconProps = props.infoIconProps;
    var indicatorEl = null;
    if (indicator === 'optional') {
        indicatorEl = React.createElement("span", { className: 'indicator' }, "(optional)");
    }
    if (indicator === 'required') {
        indicatorEl = React.createElement("span", { className: 'indicator' }, "*");
    }
    var indicatorClass = classNames({
        'optional': props.indicator === 'optional',
        'required': props.indicator === 'required'
    });
    var tooltipEl = null;
    if (infoIconProps && tooltipProps != null) {
        tooltipEl = React.createElement(tooltip_1.Tooltip, { tooltip: tooltipProps.tooltip, tooltipAlignment: tooltipProps.tooltipAlignment, tooltipPosition: tooltipProps.tooltipPosition },
            React.createElement(info_icon_1.InfoIcon, { iconContent: infoIconProps.iconContent, iconCustomTypeName: infoIconProps.iconCustomTypeName }));
    }
    else if (tooltipProps != null) {
        tooltipEl = React.createElement(tooltip_1.Tooltip, { tooltip: tooltipProps.tooltip, tooltipAlignment: tooltipProps.tooltipAlignment, tooltipPosition: tooltipProps.tooltipPosition });
    }
    else if (infoIconProps != null) {
        tooltipEl = React.createElement(info_icon_1.InfoIcon, { iconContent: infoIconProps.iconContent, iconCustomTypeName: infoIconProps.iconCustomTypeName });
    }
    return React.createElement("div", { className: indicatorClass },
        label,
        " ",
        indicatorEl,
        " ",
        tooltipEl);
}
1225401
def _collected_label(collect, label):
    """"""
    if not collect.__name__.startswith('<'):
        return label + ' ' + collect.__name__
    else:
        return label
1107315
public function get_label($field) {
		return isset($this->labels[$field]) ? $this->labels[$field] : $this->humanize_field_name($field);
	}
45600
def check_labels(self):
        
        for entry in self.labels:
            self.check_is_declared(entry.name, entry.lineno, CLASS.label)
453115
def labels(self):
        

        if type(self.object_list) == type([]):
            model = self.formset.model
        else:
            model = self.object_list.model

        for field in self.visible_fields:
            name = None
            if self.formset:
                f = self.formset.empty_form.fields.get(field, None)
                if f:
                    name = f.label

            if name is None:
                name = label_for_field(field, model)

            if name == model._meta.verbose_name:
                name = self.model_name and self.model_name or \
                            model._meta.verbose_name

            stype = None
            cur_sorted = False

            sortable = False

            if self.order_type:
                sortable = get_sort_field(field, model)
                stype = self.ASC

                # change order_type so that next sorting on the same
                # field will give reversed results
                if sortable and field == self.sort_field:
                    cur_sorted = True
                    if self.order_type == self.ASC:
                        stype = self.DESC
                    elif self.order_type == self.DESC:
                        stype = self.ASC
                    else:
                        stype = self.ASC


            yield AdminListLabel(name, field, stype, cur_sorted, bool(sortable))
1021035
def describe_field(field_definition):
    
    field_descriptor = FieldDescriptor()
    field_descriptor.name = field_definition.name
    field_descriptor.number = field_definition.number
    field_descriptor.variant = field_definition.variant

    if isinstance(field_definition, messages.EnumField):
        field_descriptor.type_name = field_definition.type.definition_name()

    if isinstance(field_definition, messages.MessageField):
        field_descriptor.type_name = (
            field_definition.message_type.definition_name())

    if field_definition.default is not None:
        field_descriptor.default_value = _DEFAULT_TO_STRING_MAP[
            type(field_definition)](field_definition.default)

    # Set label.
    if field_definition.repeated:
        field_descriptor.label = FieldDescriptor.Label.REPEATED
    elif field_definition.required:
        field_descriptor.label = FieldDescriptor.Label.REQUIRED
    else:
        field_descriptor.label = FieldDescriptor.Label.OPTIONAL

    return field_descriptor
487649
def get_field_label(self, trans, field):
        
        try:
            # get from the instance
            object_field_label = trans._meta.get_field_by_name(field)[0].verbose_name
        except Exception:
            try:
                # get from the class
                object_field_label = self.sender._meta.get_field_by_name(field)[0].verbose_name
            except Exception:
                # in the worst case we set the field name as field label
                object_field_label = field
        return object_field_label
871975
def get_labels(self, field):
        """"""
        return {c: self.cluster_meta.get(field, c)
                for c in self.clustering.cluster_ids}
1328647
def label(self, value):
        
        # Fixed width label formatting
        value = value[:self.pad_size] if self.pad_size else value
        try:
            padding = ' ' * (self.pad_size - len(value)) if self.pad_size else ''
        except TypeError:
            padding = ''

        self._formatted = ' {v}{p} '.format(v=value, p=padding)
498489
def label(self,x,y,label,offset=[0,0]):
        """"""
        (xc,yc)=self.p2c([x,y])
        return self.create_text(xc-offset[0],yc-offset[1],text=label)
369357
public void addField(String label,Element field)
    {
        if (label==null)
            label="&nbsp;";
        else
            label="<b>"+label+":</b>";

        if (extendRow)
        {
            column.add(field);
            extendRow=false;
        }
        else
        {
            column.newRow();
            column.addCell(label);
            column.cell().right();
        
            if (fieldAttributes != null)
            {
                column.addCell(field,fieldAttributes);
                fieldAttributes = null;
            }
            else
                column.addCell(field);
        }
    }
213775
def label_from_instance(self, obj):
        
        return '%s %s' % (self.level_indicator * getattr(obj, obj._mptt_meta.level_attr), obj)
864786
def labeled(**kwargs):
    """"""
    def for_practice(practice):
        """assigns label to practice"""
        practice.code = kwargs.pop('code')
        practice.msg = kwargs.pop('msg')
        practice.solution = kwargs.pop('solution')
        return practice
    return for_practice
927814
def label(self) -> str:
        """"""
        label = self.expression.replace("_", "\\;")
        if self.units_kind:
            symbol = wt_units.get_symbol(self.units)
            for v in self.variables:
                vl = "%s_{%s}" % (symbol, v.label)
                vl = vl.replace("_{}", "")  # label can be empty, no empty subscripts
                label = label.replace(v.natural_name, vl)
            units_dictionary = getattr(wt_units, self.units_kind)
            label += r"\,"
            label += r"\left("
            label += units_dictionary[self.units][2]
            label += r"\right)"
        label = r"$\mathsf{%s}$" % label
        return label
99901
def p_label_line_co(p):
    
    lbl = make_label(p[1], p.lineno(1))
    p[0] = make_block(lbl, p[2]) if len(p) == 3 else lbl
1217727
public void markAsVisited(final Field field) {
        final OneOf oneOfAnnotation = field.getAnnotation(OneOf.class);
        if (oneOfAnnotation != null) {
            final OneOfGroup oneOfGroup = this.mapping.get(oneOfAnnotation.value());
            oneOfGroup.satisfiedBy.add(new OneOfSatisfier(field, false));
        }
        final CanSatisfyOneOf canSatisfyOneOf = field.getAnnotation(CanSatisfyOneOf.class);
        if (canSatisfyOneOf != null) {
            final OneOfGroup oneOfGroup = this.mapping.get(canSatisfyOneOf.value());
            oneOfGroup.satisfiedBy.add(new OneOfSatisfier(field, true));
        }
    }
690103
def get_label(self):
        
        if self.label is None:
            self.label = self.get_field('label')
        return self.label