class SubscriptableIterable:
    def __init__(self, iterable):
        iterator = iter(iterable)
        self._first_item = next(iterator)
        self._iter = chain([self._first_item], iterator)

    def __getitem__(self, index):
        if index == 0:
            return self._first_item
        raise IndexError

    def __iter__(self):
        return self

    def __next__(self):
        return next(self._iter)


class StreamingDataset(Dataset):
    def __init__(self, data=None, **kwargs):
        super().__init__(**kwargs)

        if data is not None:
            self.set_data(data)

    def set_data(self, data):
        self._data = _SubscriptableIterable(map(Row, data))

    def __iter__(self):
        return self

    def __next__(self):
        return next(self._data)

    def __repr__(self):
        try:
            return "<%s streaming dataset>" % (self.title.lower())
        except AttributeError:
            return "<streaming dataset>"

    def _apply_formatters(self):
        if not self._formatters:
            yield from self._data
        for row in self._data:
            for col, callback in self._formatters:
                try:
                    if col is None:
                        for j, c in enumerate(row):
                            row[j] = callback(c)
                    else:
                        row[col] = callback(row[col])
                except IndexError:
                    raise InvalidDatasetIndex
                yield row

    def _package(self, dicts=True, ordered=True):
        """Packages Dataset into lists of dictionaries for transmission."""

        if ordered:
            dict_pack = OrderedDict
        else:
            dict_pack = dict

        data = self._apply_formatters()

        if self.headers:
            if dicts:
                data = (dict_pack(zip(self.headers, data_row)) for data_row in data)
            else:
                data = chain([self.headers], data)

        return data