Append a Printable Image at the end of the current instance.
        :param other: another PrintableImage
        :return: PrintableImage containing data from both self and other
554058
def append(self, other):
        
        self.data.extend(other.data)
        self.height = self.height + other.height
        return self
1347555
def join(self, other):
        ''' '''
        if self.field == other.field:
            return self, other

        _, f1, f2 = Constructible.join_fields(self.field, other.field)
        return f1(self), f2(other)
133185
def union(self, other):
        
        if self._slideDuration != other._slideDuration:
            raise ValueError("the two DStream should have same slide duration")
        return self.transformWith(lambda a, b: a.union(b), other, True)
981619
def append(self, other):
        

        to_concat = [self]

        if isinstance(other, (list, tuple)):
            to_concat = to_concat + list(other)
        else:
            to_concat.append(other)

        for obj in to_concat:
            if not isinstance(obj, Index):
                raise TypeError('all inputs must be Index')

        names = {obj.name for obj in to_concat}
        name = None if len(names) > 1 else self.name

        return self._concat(to_concat, name)
252720
def union(self, other):
        
        if isinstance(other, self.__class__):
            return self.client.sunion([self.name, other.name])
        else:
            return self._as_set().union(other)
207013
def wrap(self, other):
        """"""
        if other.childs:
            raise TagError(self, "Wrapping in a non empty Tag is forbidden.")
        if self.parent:
            self.before(other)
            self.parent.pop(self._own_index)
        other.append(self)
        return self
1018545
def Append(self, other):
        
        orig_len = len(self)
        self.Set(orig_len + len(other))
        ipoint = orig_len
        if hasattr(self, 'SetPointError'):
            for point in other:
                self.SetPoint(ipoint, point.x.value, point.y.value)
                self.SetPointError(
                    ipoint,
                    point.x.error_low, point.x.error_hi,
                    point.y.error_low, point.y.error_hi)
                ipoint += 1
        else:
            for point in other:
                self.SetPoint(ipoint, point.x.value, point.y.value)
                ipoint += 1
1101671
def update(self, other):
        
        if isinstance(other, Properties):
            other = other.defined
        for n, v in other.items():
            self.set(n, v)
        return self
773688
def merge(self, other):
        
        other = StringCell.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 string '%s' with '%s'" % \
                    (self, other))
        else:
            self._perform_merge(other)
        return self
1044590
def extendleft(self, other):
        
        def extendleft_trans(pipe):
            values = list(other.__iter__(pipe)) if use_redis else other
            for v in values:
                self._appendleft_helper(v, pipe)

        if self._same_redis(other, RedisCollection):
            use_redis = True
            self._transaction(extendleft_trans, other.key)
        else:
            use_redis = False
            self._transaction(extendleft_trans)
69104
def update(self, other):
        
        if type(self) != type(other):
            return NotImplemented
        else:
            if other.bad:
                self.error = other.error
                self.bad = True
            self._fieldDict.update(other._fieldDict)
1180656
def append_child(self, child):
        
        child.parent = self
        self.children.append(child)
        self.changed()
904150
public function add($other, array $options = []): Image
    {
        if (self::isImageish($other)) {
            return self::call('add', $this, [$other], $options);
        } else {
            return $this->linear(1, $other, $options);
        }
    }
153401
def extend(self, other):
        
        def extend_trans(pipe):
            values = list(other.__iter__(pipe)) if use_redis else other
            for v in values:
                self._append_helper(v, pipe)

        if self._same_redis(other, RedisCollection):
            use_redis = True
            self._transaction(extend_trans, other.key)
        else:
            use_redis = False
            self._transaction(extend_trans)
434206
def merge(self, other):
        ''''''
        assert self.refnames == other.refnames
        assert self.dirs == other.dirs
        assert self.lengths == other.lengths

        for i in range(2):
            if self.pos[i] is None:
                if other.pos[i] is None:
                   raise Error('Error merging these two links:\n' + str(self) + '\n' + str(other))
                self.pos[i] = other.pos[i]
            else:
                if other.pos[i] is not None:
                   raise Error('Error merging these two links:\n' + str(self) + '\n' + str(other))
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
1266039
def add(self, a, b):
        
        self.send_add(a, b)
        return self.recv_add()