Iterate through new happenings as they arrive::

            async for happening in \\
                    world.new_happenings(region='the north pacific'):
                # Your processing code here
                print(happening.text)  # As an example

        Guarantees that:

        * Every happening is generated from the moment the generator
          is started;
        * No happening is generated more than once;
        * Happenings are generated in order from oldest to newest.

        Parameters
        ----------
        poll_period : int
            How long to wait between requesting the next portion of
            happenings, in seconds.  Note that this should only be
            tweaked for latency reasons, as the function gives a
            guarantee that all happenings will be generated.

            Also note that, regardless of the ``poll_period`` set, all
            of the code in your loop body still has to execute (likely
            several times) before a new portion of happenings can be
            requested.  Consider wrapping your happening-processing code
            in a coroutine and launching it as a task from the loop body
            if you suspect this might become an issue.

            Requests made by this generator are, of course, subject to
            the API rate limit, and if the limiter has to temporarily
            block new requests the time spent waiting will be added on
            top of ``poll_period``.
        nations : iterable of str
            Nations happenings of which will be requested.  Cannot be
            specified at the same time with ``regions``.
        regions : iterable of str
            Regions happenings of which will be requested.  Cannot be
            specified at the same time with ``nations``.
        filters : iterable of str
            Categories to request happenings by.  Available filters
            are: ``law``, ``change``, ``dispatch``, ``rmb``,
            ``embassy``, ``eject``, ``admin``, ``move``, ``founding``,
            ``cte``, ``vote``, ``resolution``, ``member``, and ``endo``.

        Returns
        -------
        an asynchronous iterator yielding any of the classes from \
        the :mod:`~aionationstates.happenings` module

async def new_happenings(self, poll_period=30, *, nations=None,
                             regions=None, filters=None):
        """Iterate through new happenings as they arrive::

            async for happening in \\
                    world.new_happenings(region='the north pacific'):
                # Your processing code here
                print(happening.text)  # As an example

        Guarantees that:

        * Every happening is generated from the moment the generator
          is started;
        * No happening is generated more than once;
        * Happenings are generated in order from oldest to newest.

        Parameters
        ----------
        poll_period : int
            How long to wait between requesting the next portion of
            happenings, in seconds.  Note that this should only be
            tweaked for latency reasons, as the function gives a
            guarantee that all happenings will be generated.

            Also note that, regardless of the ``poll_period`` set, all
            of the code in your loop body still has to execute (likely
            several times) before a new portion of happenings can be
            requested.  Consider wrapping your happening-processing code
            in a coroutine and launching it as a task from the loop body
            if you suspect this might become an issue.

            Requests made by this generator are, of course, subject to
            the API rate limit, and if the limiter has to temporarily
            block new requests the time spent waiting will be added on
            top of ``poll_period``.
        nations : iterable of str
            Nations happenings of which will be requested.  Cannot be
            specified at the same time with ``regions``.
        regions : iterable of str
            Regions happenings of which will be requested.  Cannot be
            specified at the same time with ``nations``.
        filters : iterable of str
            Categories to request happenings by.  Available filters
            are: ``law``, ``change``, ``dispatch``, ``rmb``,
            ``embassy``, ``eject``, ``admin``, ``move``, ``founding``,
            ``cte``, ``vote``, ``resolution``, ``member``, and ``endo``.

        Returns
        -------
        an asynchronous iterator yielding any of the classes from \
        the :mod:`~aionationstates.happenings` module
        """
        try:
            # We only need the happenings from this point forwards
            last_id = (await self._get_happenings(
                nations=nations, regions=regions, filters=filters,
                limit=1))[0].id
        except IndexError:
            # Happenings before this point have all been deleted
            last_id = 0

        while True:
            # Sleep before the loop body to avoid wasting the first request
            await sleep(poll_period)

            # I don't think there's a cleaner solution, sadly.
            happenings = []
            async for happening in self.happenings(
                    nations=nations, regions=regions, filters=filters):
                if happening.id <= last_id:
                    break
                happenings.append(happening)

            with suppress(IndexError):
                last_id = happenings[0].id

            for happening in reversed(happenings):
                yield happening