code: def acquire(self, blocking=True):
          
          sleep = self.sleep
          timeout = self.timeout
          while 1:
              unixtime = time.time()
              if timeout:
                  timeout_at = unixtime + timeout
              else:
                  timeout_at = Lock.LOCK_FOREVER
              timeout_at = float(timeout_at)
              if self.redis.setnx(self.name, timeout_at):
                  self.acquired_until = timeout_at
                  return True
              # We want blocking, but didn't acquire the lock
              # check to see if the current lock is expired
              try:
                  existing = float(self.redis.get(self.name) or 1)
              except ValueError:
                  existing = Lock.LOCK_FOREVER
  
              if existing < unixtime:
                  # the previous lock is expired, attempt to overwrite it
                  try:
                      existing = float(self.redis.getset(self.name, timeout_at) or 1)
                  except ValueError:
                      existing = Lock.LOCK_FOREVER
                  if existing < unixtime:
                      # we successfully acquired the lock
                      self.acquired_until = timeout_at
                      return True
              if not blocking:
                  return False
              time.sleep(sleep)
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.