Applies labels for default meta labels from other onto self.
        
        Parameters
        ----------
        other : Meta
            Meta object to take default labels from
        
        Returns
        -------
        Meta
483232
def accept_default_labels(self, other):
        

        self.units_label = other.units_label
        self.name_label = other.name_label
        self.notes_label = other.notes_label
        self.desc_label = other.desc_label
        self.plot_label = other.plot_label
        self.axis_label = other.axis_label
        self.scale_label = other.scale_label
        self.min_label = other.min_label
        self.max_label = other.max_label
        self.fill_label = other.fill_label
        return
1203623
function labels (configName, callback) {

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

    return get(configName).schema.statics.getLabels();
}
911913
def update(self, *others):
        
        for other in others:
            for key, val in other.items():
                self[key] = val
            try:
                if not other.success:
                    self.success = False
                    self.reason = other.reason
            except AttributeError:
                pass
1255639
def update(self, other):
        
        if isinstance(other, NdMapping):
            dims = [d for d in other.kdims if d not in self.kdims]
            if len(dims) == other.ndims:
                raise KeyError("Cannot update with NdMapping that has"
                               " a different set of key dimensions.")
            elif dims:
                other = other.drop_dimension(dims)
            other = other.data
        for key, data in other.items():
            self._add_item(key, data, sort=False)
        if self.sort:
            self._resort()
768335
def set_meta(self, instance):
        
        self.use_title_tag = True
        self.title = instance.title
1045989
def meta_set(self, key, metafield, value):
        
        self._meta.setdefault(key, {})[metafield] = value
145109
def link_in(self, other, preserve=False):
        
        if preserve:
            other = other.clone()
        link_modules(self, other)
1314099
def labels(self):
        
        if not self.__labels:
            self.__labels = Labels(self.__connection)
        return self.__labels
824679
def copy_metadata(self, other):
        
        logging.info("Copying metadata")
        # copy attributes
        for key in self.attrs.keys():
            other.attrs[key] = self.attrs[key]
605208
def _other_to_dict(self, other):
    
    if isinstance(other, ModelBase):
      return other.to_dict()
    elif isinstance(other, list):
      # TODO: what if it's not a list?
      return [self._other_to_dict(i) for i in other]
    else:
      return other
328709
def lookup_field_label(self, context, field, default=None):
        
        # if this is a subfield, strip off everything but the last field name
        if field.find('.') >= 0:
            return self.lookup_field_label(context, field.split('.')[-1], default)

        label = None

        # is there a label specified for this field
        if field in self.field_config and 'label' in self.field_config[field]:
            label = self.field_config[field]['label']

        # if we were given a default, use that
        elif default:
            label = default

        # check our model
        else:
            for model_field in self.model._meta.fields:
                if model_field.name == field:
                    return model_field.verbose_name.title()

        # otherwise, derive it from our field name
        if label is None:
            label = self.derive_field_label(field)

        return label
366641
def AddClientLabels(self, client_id, owner, labels):
    """"""
    if client_id not in self.metadatas:
      raise db.UnknownClientError(client_id)

    labelset = self.labels.setdefault(client_id, {}).setdefault(owner, set())
    for l in labels:
      labelset.add(utils.SmartUnicode(l))
927393
def __label_cmp(self, other):
        
        if other is None:
            return -1

        label_name = strip_accents(self.name).lower()
        other_name = strip_accents(other.name).lower()
        if label_name < other_name:
            return -1
        elif label_name == other_name:
            return 0
        else:
            return 1

        if self.get_color_str() < other.get_color_str():
            return -1
        elif self.get_color_str() == other.get_color_str():
            return 0
        else:
            return 1
1069635
def labels(self, filters=None, params=None):
        
        if not self.can_update():
            self._tcex.handle_error(910, [self.type])

        for l in self.tc_requests.labels(
            self.api_type,
            self.api_sub_type,
            self.unique_id,
            owner=self.owner,
            filters=filters,
            params=params,
        ):
            yield l
1000030
def filter(self, other):
        

        self.canonify()
        other.canonify()

        rej = self.__class__()
        rej.optlist = self.optlist.difference(other.optlist)
        self.optlist.difference_update(rej.optlist)
        for x in self.optdict.copy():
             if x not in other.optdict:
                 self.optdict.pop(x)
                 rej.optdict[x] = None

        return rej
126310
def concatenate(self, other):
        

        if self.is_absolute() and len(other) > 0:
            raise AbsoluteConcatenation
        labels = list(self.labels)
        labels.extend(list(other.labels))
        return Name(labels)
614885
def merge(self, other):
        
        other = PrefixCell.coerce(other)
        if self.is_equal(other):
            # pick among dependencies
            return self
        elif other.is_entailed_by(self):
            return self
        elif self.is_entailed_by(other):
            self.value = other.value
        elif self.is_contradictory(other):
            raise Contradiction("Cannot merge prefix '%s' with '%s'" % \
                    (self, other))
        else:
            if len(self.value) > len(other.value):
                self.value = other.value[:]
            # otherwise, return self
        return self