<SYSTEM_TASK:>
Solve the following problem using Python, implementing the functions described below, one line at a time
<END_TASK>
<USER_TASK:>
Description:
 def get_history( self, chat_id: Union[int, str], limit: int = 100, offset: int = 0, offset_id: int = 0, offset_date: int = 0, reverse: bool = False ):
 """Use this method to retrieve a chunk of the history of a chat. You can get up to 100 messages at once. For a more convenient way of getting a chat history see :meth:`iter_history`. Args: chat_id (``int`` | ``str``):
 Unique identifier (int) or username (str) of the target chat. For your personal cloud (Saved Messages) you can simply use "me" or "self". For a contact that exists in your Telegram address book you can use his phone number (str). limit (``int``, *optional*):
 Limits the number of messages to be retrieved. By default, the first 100 messages are returned. offset (``int``, *optional*):
 Sequential number of the first message to be returned. Defaults to 0 (most recent message). Negative values are also accepted and become useful in case you set offset_id or offset_date. offset_id (``int``, *optional*):
 Pass a message identifier as offset to retrieve only older messages starting from that message. offset_date (``int``, *optional*):
 Pass a date in Unix time as offset to retrieve only older messages starting from that date. reverse (``bool``, *optional*):
 Pass True to retrieve the messages in reversed order (from older to most recent). Returns: On success, a :obj:`Messages <pyrogram.Messages>` object is returned. Raises: :class:`RPCError <pyrogram.RPCError>` in case of a Telegram RPC error. """


        while True:
            try:
                messages = pyrogram.Messages._parse(
                    self,
                    self.send(
                        functions.messages.GetHistory(
                            peer=self.resolve_peer(chat_id),
                            offset_id=offset_id,
                            offset_date=offset_date,
                            add_offset=offset * (-1 if reverse else 1) - (limit if reverse else 0),
                            limit=limit,
                            max_id=0,
                            min_id=0,
                            hash=0
                        )
                    )
                )
            except FloodWait as e:
                log.warning("Sleeping for {}s".format(e.x))
                time.sleep(e.x)
            else:
                break

        if reverse:
            messages.messages.reverse()

        return messages