docs: def find_all(self, selector, **kwargs):
          """Return all the elements found with a selector
  
          Args:
              selector (str): the selector used to find the element
  
          Kwargs:
              wait_until_present (bool) default configurable via
                  proxy_driver:wait_until_present_before_find
              wait_until_visible (bool) default configurable via
                  proxy_driver:wait_until_visible_before_find
              raise_exception (bool) default configurable via
                  proxy_driver:raise_exception
  
          Returns:
              empty list if no element was found
              proxy_element_list when element are found
  
          Raises:
              this function might raise an exception depending on the
                  raise_exception kwargs
              or
              the config proxy_driver:raise_exception
          """
  
          self.debug_log("Finding elements with selector: %s" % selector)
  
          raise_exception = kwargs.get(
              'raise_exception',
              BROME_CONFIG['proxy_driver']['raise_exception']
          )
          self.debug_log("effective raise_exception: %s" % raise_exception)
  
          wait_until_present = kwargs.get(
              'wait_until_present',
              BROME_CONFIG['proxy_driver']['wait_until_present_before_find']
          )
  
          self.debug_log(
              "effective wait_until_present: %s" % wait_until_present
          )
  
          wait_until_visible = kwargs.get(
              'wait_until_visible',
              BROME_CONFIG['proxy_driver']['wait_until_visible_before_find']
          )
          self.debug_log(
              "effective wait_until_visible: %s" % wait_until_visible
          )
  
          _selector = Selector(self, selector)
  
          found = False
          if wait_until_visible:
              # we don't raise exception here otherwise none visible
              # element will always raise exception
              # TODO find a good way to make it configurable
              found = self.wait_until_visible(selector, raise_exception=False)
  
          if wait_until_present and not found:
              found = self.wait_until_present(
                  selector,
                  raise_exception=raise_exception
              )
              if not found:
                  self.debug_log("find_all (%s): No element found" % _selector)
                  return []
  
          try:
              elements = getattr(
                  self._driver,
                  _selector.find_function
              )(_selector.get_selector())
          except exceptions.NoSuchElementException:
              self.debug_log("find_all (%s): No element found" % _selector)
              self.print_javascript_error()
              if raise_exception:
                  raise exceptions.NoSuchElementException(_selector)
              else:
                  return []
  
          if type(elements) == list:
              if len(elements):
                  self.debug_log("find_all (%s): Element found" % _selector)
                  return ProxyElementList(elements, _selector, self)
              else:
                  msg = "find_all (%s): No element found" % _selector
                  self.debug_log(msg)
                  self.print_javascript_error()
                  if raise_exception:
                      raise exceptions.NoSuchElementException(msg)
                  else:
                      return []
          else:
              self.debug_log("find_all (%s): Element found" % _selector)
              return [ProxyElement(elements, _selector, self)]