docs: def exists(self, pattern, seconds=None):
          """ Searches for an image pattern in the given region
  
          Returns Match if pattern exists, None otherwise (does not throw exception)
          Sikuli supports OCR search with a text parameter. This does not (yet).
          """
          find_time = time.time()
          r = self.clipRegionToScreen()
          if r is None:
              raise ValueError("Region outside all visible screens")
              return None
          if seconds is None:
              seconds = self.autoWaitTimeout
          if isinstance(pattern, int):
              # Actually just a "wait" statement
              time.sleep(pattern)
              return
          if not pattern:
              time.sleep(seconds)
          if not isinstance(pattern, Pattern):
              if not isinstance(pattern, basestring):
                  raise TypeError("find expected a string [image path] or Pattern object")
              pattern = Pattern(pattern)
          needle = cv2.imread(pattern.path)
          if needle is None:
              raise ValueError("Unable to load image '{}'".format(pattern.path))
          needle_height, needle_width, needle_channels = needle.shape
          match = None
          timeout = time.time() + seconds
  
          # Consult TemplateMatcher to find needle
          while not match:
              matcher = TemplateMatcher(r.getBitmap())
              match = matcher.findBestMatch(needle, pattern.similarity)
              time.sleep(1/self._defaultScanRate if self._defaultScanRate is not None else 1/Settings.WaitScanRate)
              if time.time() > timeout:
                  break
  
          if match is None:
              Debug.info("Couldn't find '{}' with enough similarity.".format(pattern.path))
              return None
  
          # Translate local position into global screen position
          position, confidence = match
          position = (position[0] + self.x, position[1] + self.y)
          self._lastMatch = Match(
              confidence,
              pattern.offset,
              (position, (needle_width, needle_height)))
          #self._lastMatch.debug_preview()
          Debug.info("Found match for pattern '{}' at ({},{}) with confidence ({}). Target at ({},{})".format(
              pattern.path,
              self._lastMatch.getX(),
              self._lastMatch.getY(),
              self._lastMatch.getScore(),
              self._lastMatch.getTarget().x,
              self._lastMatch.getTarget().y))
          self._lastMatchTime = (time.time() - find_time) * 1000 # Capture find time in milliseconds
          return self._lastMatch