text: """
  Sends updates to a Telegram bot.
  """
  from __future__ import absolute_import
  
  from concurrent.futures import ThreadPoolExecutor
  from requests import Session
  
  from tqdm.auto import tqdm as tqdm_auto
  from tqdm.utils import _range
  __author__ = {"github.com/": ["casperdcl"]}
  __all__ = ['TelegramIO', 'tqdm_telegram', 'ttgrange', 'tqdm', 'trange']
  
  
  class TelegramIO():
      """Non-blocking file-like IO to a Telegram Bot."""
      API = 'https://api.telegram.org/bot'
  
      def __init__(self, token, chat_id):
          """Creates a new message in the given `chat_id`."""
          self.token = token
          self.chat_id = chat_id
          self.session = session = Session()
          self.text = self.__class__.__name__
          self.pool = ThreadPoolExecutor()
          self.futures = []
          try:
              res = session.post(
                  self.API + '%s/sendMessage' % self.token,
                  data=dict(text='`' + self.text + '`', chat_id=self.chat_id,
                            parse_mode='MarkdownV2'))
          except Exception as e:
              tqdm_auto.write(str(e))
          else:
              self.message_id = res.json()['result']['message_id']
  
      def write(self, s):
          """Replaces internal `message_id`'s text with `s`."""
          if not s:
              return
          s = s.strip().replace('\r', '')
          if s == self.text:
              return  # avoid duplicate message Bot error
          self.text = s
          try:
              f = self.pool.submit(
                  self.session.post,
                  self.API + '%s/editMessageText' % self.token,
                  data=dict(
                      text='`' + s + '`', chat_id=self.chat_id,
                      message_id=self.message_id, parse_mode='MarkdownV2'))
          except Exception as e:
              tqdm_auto.write(str(e))
          else:
              self.futures.append(f)
              return f
  
      def flush(self):
          """Ensure the last `write` has been processed."""
          [f.cancel() for f in self.futures[-2::-1]]
          try:
              return self.futures[-1].result()
          except IndexError:
              pass
          finally:
              self.futures = []
  
      def __del__(self):
          self.flush()
  
  
  class tqdm_telegram(tqdm_auto):
      """
      Standard `tqdm.auto.tqdm` but also sends updates to a Telegram bot.
      May take a few seconds to create (`__init__`) and clear (`__del__`).
  
      >>> from tqdm.contrib.telegram import tqdm, trange
      >>> for i in tqdm(
      ...     iterable,
      ...     token='1234567890:THIS1SSOMETOKEN0BTAINeDfrOmTELEGrAM',
      ...     chat_id='0246813579'):
      """
      def __init__(self, *args, **kwargs):
          """
          Parameters
          ----------
          token  : str, required. Telegram token.
          chat_id  : str, required. Telegram chat ID.
  
          See `tqdm.auto.tqdm.__init__` for other parameters.
          """
          self.tgio = TelegramIO(kwargs.pop('token'), kwargs.pop('chat_id'))
          super(tqdm_telegram, self).__init__(*args, **kwargs)
  
      def display(self, **kwargs):
          super(tqdm_telegram, self).display(**kwargs)
          fmt = self.format_dict
          if 'bar_format' in fmt and fmt['bar_format']:
              fmt['bar_format'] = fmt['bar_format'].replace('<bar/>', '{bar}')
          else:
              fmt['bar_format'] = '{l_bar}{bar}{r_bar}'
          fmt['bar_format'] = fmt['bar_format'].replace('{bar}', '{bar:10u}')
          self.tgio.write(self.format_meter(**fmt))
  
      def __new__(cls, *args, **kwargs):
          """
          Workaround for mixed-class same-stream nested progressbars.
          See [#509](https://github.com/tqdm/tqdm/issues/509)
          """
          with cls.get_lock():
              try:
                  cls._instances = tqdm_auto._instances
              except AttributeError:
                  pass
          instance = super(tqdm_telegram, cls).__new__(cls, *args, **kwargs)
          with cls.get_lock():
              try:
                  # `tqdm_auto` may have been changed so update
                  cls._instances.update(tqdm_auto._instances)
              except AttributeError:
                  pass
              tqdm_auto._instances = cls._instances
          return instance
  
  
  def ttgrange(*args, **kwargs):
      """
      A shortcut for `tqdm.contrib.telegram.tqdm(xrange(*args), **kwargs)`.
      On Python3+, `range` is used instead of `xrange`.
      """
      return tqdm_telegram(_range(*args), **kwargs)
  
  
  # Aliases
  tqdm = tqdm_telegram
  trange = ttgrange
  