code: def acquire(self, blocking=True,
                  delay=DELAY_INCREMENT, max_delay=MAX_DELAY,
                  timeout=None):
          
          if delay < 0:
              raise ValueError("Delay must be greater than or equal to zero")
          if timeout is not None and timeout < 0:
              raise ValueError("Timeout must be greater than or equal to zero")
          if delay >= max_delay:
              max_delay = delay
          self._do_open()
          watch = _utils.StopWatch(duration=timeout)
          r = _utils.Retry(delay, max_delay,
                           sleep_func=self.sleep_func, watch=watch)
          with watch:
              gotten = r(self._try_acquire, blocking, watch)
          if not gotten:
              self.acquired = False
              return False
          else:
              self.acquired = True
              self.logger.log(_utils.BLATHER,
                              "Acquired file lock `%s` after waiting %0.3fs [%s"
                              " attempts were required]", self.path,
                              watch.elapsed(), r.attempts)
              return True
docs: Attempt to acquire the given lock.
  
          :param blocking: whether to wait forever to try to acquire the lock
          :type blocking: bool
          :param delay: when blocking this is the delay time in seconds that
                        will be added after each failed acquisition
          :type delay: int/float
          :param max_delay: the maximum delay to have (this limits the
                            accumulated delay(s) added after each failed
                            acquisition)
          :type max_delay: int/float
          :param timeout: an optional timeout (limits how long blocking
                          will occur for)
          :type timeout: int/float
          :returns: whether or not the acquisition succeeded
          :rtype: bool