def split(self, cutting_points, shift_times=False, overlap=0.0):
        """
        Split the label-list into x parts and return them as new label-lists.
        x is defined by the number of cutting-points(``x == len(cutting_points) + 1``)

        The result is a list of label-lists corresponding to each part.
        Label-list 0 contains labels between ``0`` and ``cutting_points[0]``.
        Label-list 1 contains labels between ``cutting_points[0]`` and ``cutting_points[1]``.
        And so on.

        Args:
            cutting_points(list): List of floats defining the points in seconds,
                                  where the label-list is splitted.
            shift_times(bool): If True, start and end-time are shifted in splitted label-lists.
                               So the start is relative to the cutting point and
                               not to the beginning of the original label-list.
            overlap(float): Amount of overlap in seconds. This amount is subtracted
                            from a start-cutting-point, and added to a end-cutting-point.

        Returns:
            list: A list of of: class: `audiomate.annotations.LabelList`.

        Example:

            >>> ll = LabelList(labels=[
            >>>     Label('a', 0, 5),
            >>>     Label('b', 5, 10),
            >>>     Label('c', 11, 15),
            >>>])
            >>>
            >>> res = ll.split([4.1, 8.9, 12.0])
            >>> len(res)
            4
            >>> res[0].labels
            [Label('a', 0.0, 4.1)]
            >>> res[1].labels
            [
                Label('a', 4.1, 5.0),
                Label('b', 5.0, 8.9)
            ]
            >>> res[2].labels
            [
                Label('b', 8.9, 10.0),
                Label('c', 11.0, 12.0)
            ]
            >>> res[3].labels
            [Label('c', 12.0, 15.0)]

        If ``shift_times = True``, the times are adjusted to be relative
        to the cutting-points for every label-list but the first.

            >>> ll = LabelList(labels=[
            >>>     Label('a', 0, 5),
            >>>     Label('b', 5, 10),
            >>>])
            >>>
            >>> res = ll.split([4.6])
            >>> len(res)
            4
            >>> res[0].labels
            [Label('a', 0.0, 4.6)]
            >>> res[1].labels
            [
                Label('a', 0.0, 0.4),
                Label('b', 0.4, 5.4)
            ]
        """

        if len(cutting_points) == 0:
            raise ValueError('At least one cutting-point is needed!')

        # we have to loop in sorted order
        cutting_points = sorted(cutting_points)

        splits = []
        iv_start = 0.0

        for i in range(len(cutting_points) + 1):
            if i < len(cutting_points):
                iv_end = cutting_points[i]
            else:
                iv_end = float('inf')

            # get all intervals intersecting range
            intervals = self.label_tree.overlap(
                iv_start - overlap,
                iv_end + overlap
            )

            cp_splits = LabelList(idx=self.idx)

            # Extract labels from intervals with updated times
            for iv in intervals:
                label = copy.deepcopy(iv.data)
                label.start = max(0, iv_start - overlap, label.start)
                label.end = min(iv_end + overlap, label.end)

                if shift_times:
                    orig_start = max(0, iv_start - overlap)
                    label.start -= orig_start
                    label.end -= orig_start

                cp_splits.add(label)

            splits.append(cp_splits)
            iv_start = iv_end

        return splits
Split the label-list into x parts and return them as new label-lists.
        x is defined by the number of cutting-points(``x == len(cutting_points) + 1``)

        The result is a list of label-lists corresponding to each part.
        Label-list 0 contains labels between ``0`` and ``cutting_points[0]``.
        Label-list 1 contains labels between ``cutting_points[0]`` and ``cutting_points[1]``.
        And so on.

        Args:
            cutting_points(list): List of floats defining the points in seconds,
                                  where the label-list is splitted.
            shift_times(bool): If True, start and end-time are shifted in splitted label-lists.
                               So the start is relative to the cutting point and
                               not to the beginning of the original label-list.
            overlap(float): Amount of overlap in seconds. This amount is subtracted
                            from a start-cutting-point, and added to a end-cutting-point.

        Returns:
            list: A list of of: class: `audiomate.annotations.LabelList`.

        Example:

            >>> ll = LabelList(labels=[
            >>>     Label('a', 0, 5),
            >>>     Label('b', 5, 10),
            >>>     Label('c', 11, 15),
            >>>])
            >>>
            >>> res = ll.split([4.1, 8.9, 12.0])
            >>> len(res)
            4
            >>> res[0].labels
            [Label('a', 0.0, 4.1)]
            >>> res[1].labels
            [
                Label('a', 4.1, 5.0),
                Label('b', 5.0, 8.9)
            ]
            >>> res[2].labels
            [
                Label('b', 8.9, 10.0),
                Label('c', 11.0, 12.0)
            ]
            >>> res[3].labels
            [Label('c', 12.0, 15.0)]

        If ``shift_times = True``, the times are adjusted to be relative
        to the cutting-points for every label-list but the first.

            >>> ll = LabelList(labels=[
            >>>     Label('a', 0, 5),
            >>>     Label('b', 5, 10),
            >>>])
            >>>
            >>> res = ll.split([4.6])
            >>> len(res)
            4
            >>> res[0].labels
            [Label('a', 0.0, 4.6)]
            >>> res[1].labels
            [
                Label('a', 0.0, 0.4),
                Label('b', 0.4, 5.4)
            ]