Split op with multiple split sizes.
963517
def SplitV(a, splits, axis):
    
    return tuple(np.split(np.copy(a), np.cumsum(splits), axis=axis))
333838
function splitStr2Obj(source) {
    var result = {};
    each(
        source.split(','),
        function (key) {
            result[key] = key;
        }
    );
    return result;
}
726624
def split_vars(_vars):
    """"""
    return (
        {
            k.upper().strip(): parse_conf_data(v.strip(), tomlfy=True)
            for k, _, v in [item.partition("=") for item in _vars]
        }
        if _vars
        else {}
    )
929204
def split(self, bits_count):
		
		result = []
		array = WBinArray(self.__value, self.__size)

		if (len(array) % bits_count) > 0:
			array.resize(len(array) + (bits_count - (len(array) % bits_count)))

		while len(array):
			result.append(WBinArray(array[:bits_count], bits_count))
			array = array[bits_count:]
		return result
173448
def slice_into_pieces(seq, n):
    """"""
    length = len(seq)
    if length % n == 0:
        size = length // n
    else:
        size = length // n + 1
    for it in slice_by_size(seq, size):
        yield it
265845
def Split(axis, a, n):
    
    return tuple(np.split(np.copy(a), n, axis=axis))
307464
def split_top_down(lower, upper, __fval=None, **fval):
    
    if __fval is not None:
        fval.update(__fval)
    if lower in upper._overload_fields:
        ofval = upper._overload_fields[lower]
        if any(k not in ofval or ofval[k] != v for k, v in six.iteritems(fval)):  # noqa: E501
            return
        upper._overload_fields = upper._overload_fields.copy()
        del(upper._overload_fields[lower])
1340700
def split_tokens(self):
        """"""
        if not self._split_tokens_calculated:
            # split into items (whitespace split)
            self._split_tokens = self._line_str.split()
            self._split_tokens_calculated = True

        return self._split_tokens
1023144
function split(separator, limit) {
        var O = requireObjectCoercible(this);
        var splitter = separator == undefined ? undefined : separator[SPLIT];
        return splitter !== undefined
          ? splitter.call(separator, O, limit)
          : internalSplit.call(String(O), separator, limit);
      }
739995
def split(self, box_size):
        
        w, h = box_size
        rows = round(self.height / h)
        cols = round(self.width / w)

        boxes = []
        for row in range(rows):
            for col in range(cols):
                box = Box(self.x + (col * w), self.y + (row * h), w, h)
                boxes.append(box)
        return boxes
767677
def partition(a, sz): 
    """"""
    return [a[i:i+sz] for i in range(0, len(a), sz)]
295246
def split_all(reference, sep):
    
    parts = partition_all(reference, sep)
    return [p for p in parts if p not in sep]
1059678
def split(self, amount):
        
        split_objs = list(self.all())
        if not split_objs:
            raise NoSplitsFoundForRecurringCost()

        portions = [split_obj.portion for split_obj in split_objs]

        split_amounts = ratio_split(amount, portions)
        return [
            (split_objs[i], split_amount)
            for i, split_amount
            in enumerate(split_amounts)
        ]
70885
def splits(cls, fields, root=".data", train="en-ud-tag.v2.train.txt",
               validation="en-ud-tag.v2.dev.txt",
               test="en-ud-tag.v2.test.txt", **kwargs):
        

        return super(UDPOS, cls).splits(
            fields=fields, root=root, train=train, validation=validation,
            test=test, **kwargs)
157241
def splits(self):
        "  "
        result = []

        def collect(split):
            result.append(split)

            for item in split:
                if isinstance(item, (HSplit, VSplit)):
                    collect(item)

        collect(self.root)
        return result
348424
def ParseMultiple(self, stats, file_objs, kb):
    """"""
    fileset = {stat.pathspec.path: obj for stat, obj in zip(stats, file_objs)}
    return self.ParseFileset(fileset)
774074
def _divide(self, x1, x2, out):
        """"""
        self.tspace._divide(x1.tensor, x2.tensor, out.tensor)