docs: def takeout(
              self, finalize=True, *, contacts=None, users=None, chats=None,
              megagroups=None, channels=None, files=None, max_file_size=None):
          """
          Creates a proxy object over the current :ref:`TelegramClient` through
          which making requests will use :tl:`InvokeWithTakeoutRequest` to wrap
          them. In other words, returns the current client modified so that
          requests are done as a takeout:
  
          >>> from telethon.sync import TelegramClient
          >>>
          >>> with TelegramClient(...) as client:
          >>>     with client.takeout() as takeout:
          >>>         client.get_messages('me')  # normal call
          >>>         takeout.get_messages('me')  # wrapped through takeout
  
          Some of the calls made through the takeout session will have lower
          flood limits. This is useful if you want to export the data from
          conversations or mass-download media, since the rate limits will
          be lower. Only some requests will be affected, and you will need
          to adjust the `wait_time` of methods like `client.iter_messages
          <telethon.client.messages.MessageMethods.iter_messages>`.
  
          By default, all parameters are ``None``, and you need to enable those
          you plan to use by setting them to either ``True`` or ``False``.
  
          You should ``except errors.TakeoutInitDelayError as e``, since this
          exception will raise depending on the condition of the session. You
          can then access ``e.seconds`` to know how long you should wait for
          before calling the method again.
  
          There's also a `success` property available in the takeout proxy
          object, so from the `with` body you can set the boolean result that
          will be sent back to Telegram. But if it's left ``None`` as by
          default, then the action is based on the `finalize` parameter. If
          it's ``True`` then the takeout will be finished, and if no exception
          occurred during it, then ``True`` will be considered as a result.
          Otherwise, the takeout will not be finished and its ID will be
          preserved for future usage as `client.session.takeout_id
          <telethon.sessions.abstract.Session.takeout_id>`.
  
          Args:
              contacts (`bool`):
                  Set to ``True`` if you plan on downloading contacts.
  
              users (`bool`):
                  Set to ``True`` if you plan on downloading information
                  from users and their private conversations with you.
  
              chats (`bool`):
                  Set to ``True`` if you plan on downloading information
                  from small group chats, such as messages and media.
  
              megagroups (`bool`):
                  Set to ``True`` if you plan on downloading information
                  from megagroups (channels), such as messages and media.
  
              channels (`bool`):
                  Set to ``True`` if you plan on downloading information
                  from broadcast channels, such as messages and media.
  
              files (`bool`):
                  Set to ``True`` if you plan on downloading media and
                  you don't only wish to export messages.
  
              max_file_size (`int`):
                  The maximum file size, in bytes, that you plan
                  to download for each message with media.
          """
          request_kwargs = dict(
              contacts=contacts,
              message_users=users,
              message_chats=chats,
              message_megagroups=megagroups,
              message_channels=channels,
              files=files,
              file_max_size=max_file_size
          )
          arg_specified = (arg is not None for arg in request_kwargs.values())
  
          if self.session.takeout_id is None or any(arg_specified):
              request = functions.account.InitTakeoutSessionRequest(
                  **request_kwargs)
          else:
              request = None
  
          return _TakeoutClient(finalize, self, request)