docs: def acquire(self, blocking=None, blocking_timeout=None, token=None):
          """
          Use Redis to hold a shared, distributed lock named ``name``.
          Returns True once the lock is acquired.
  
          If ``blocking`` is False, always return immediately. If the lock
          was acquired, return True, otherwise return False.
  
          ``blocking_timeout`` specifies the maximum number of seconds to
          wait trying to acquire the lock.
  
          ``token`` specifies the token value to be used. If provided, token
          must be a bytes object or a string that can be encoded to a bytes
          object with the default encoding. If a token isn't specified, a UUID
          will be generated.
          """
          sleep = self.sleep
          if token is None:
              token = uuid.uuid1().hex.encode()
          else:
              encoder = self.redis.connection_pool.get_encoder()
              token = encoder.encode(token)
          if blocking is None:
              blocking = self.blocking
          if blocking_timeout is None:
              blocking_timeout = self.blocking_timeout
          stop_trying_at = None
          if blocking_timeout is not None:
              stop_trying_at = mod_time.time() + blocking_timeout
          while True:
              if self.do_acquire(token):
                  self.local.token = token
                  return True
              if not blocking:
                  return False
              if stop_trying_at is not None and mod_time.time() > stop_trying_at:
                  return False
              mod_time.sleep(sleep)