async def new_messages(self, poll_period=30, *, fromid=None):
        """New messages on the Regional Message Board::

            tnp = region('The North Pacific')
            async for post in tnp.new_messages():
                # Your processing code here
                print(post.text)  # As an example

        Guarantees that:

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

        Parameters
        ----------
        poll_period : int
            How long to wait between requesting the next bunch of
            posts, in seconds.  Ignored while catching up to the end
            of the Message Board, meaning that no matter how long of a
            period you set you will never encounter a situation where
            posts are made faster than the generator can deliver them.

            Note that, regardless of the ``poll_period`` you set, all
            of the code in your loop body still has to execute (possibly
            several times) before a new bunch of posts can be
            requested.  Consider wrapping your post-processing code
            in a coroutine and launching it as a task from the loop body
            if you suspect this might be an issue.
        fromid : int
            Request posts starting with the one with this id, as
            as opposed to the last one at the time.  Useful if you
            need to avoid losing posts between restarts.  Set to `1`
            to request the entire RMB history chronologically.

        Returns
        -------
        an asynchronous generator that yields :class:`Post`
        """
        if fromid is not None:
            # fromid of 0 gets ignored by NS
            fromid = 1 if fromid == 0 else fromid
        else:
            try:
                # We only need the posts from this point forwards
                fromid = (await self._get_messages(limit=1))[0].id + 1
            except IndexError:
                # Empty RMB
                fromid = 1
            # Sleep before the loop body to avoid wasting the first request.
            # We only want to apply this "optimization" if fromid was not
            # specified, as only then we know for sure we're at the end of the
            # RMB.
            await sleep(poll_period)

        while True:
            posts = await self._get_messages(fromid=fromid)

            with suppress(IndexError):
                fromid = posts[-1].id + 1

            for post in posts:
                yield post

            if len(posts) < 100:
                await sleep(poll_period)