code: async def acquire(self, blocking=None, blocking_timeout=None):
          
          sleep = self.sleep
          token = b(uuid.uuid1().hex)
          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 await 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
              await asyncio.sleep(sleep, loop=self.redis.connection_pool.loop)
docs: 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.