def wait_until_page_contains_element(self, locator, timeout=None, error=None):

        """Waits until element specified with `locator` appears on current page.

        Fails if `timeout` expires before the element appears. See

        `introduction` for more information about `timeout` and its

        default value.

        `error` can be used to override the default error message.

        See also `Wait Until Page Contains`, `Wait For Condition`,

        `Wait Until Element Is Visible` and BuiltIn keyword `Wait Until

        Keyword Succeeds`.

        """

        if not error:

            error = "Element '%s' did not appear in <TIMEOUT>" % locator

        self._wait_until(timeout, error, self._is_element_present, locator)

def _wait_until_no_error(self, timeout, wait_func, *args):

        timeout = robot.utils.timestr_to_secs(timeout) if timeout is not None else self._timeout_in_secs

        maxtime = time.time() + timeout

        while True:

            timeout_error = wait_func(*args)

            if not timeout_error: return

            if time.time() > maxtime:

                raise AssertionError(timeout_error)

            time.sleep(0.2)

    def until(self, method, message=''):

        """Calls the method provided with the driver as an argument until the \

        return value is not False."""

        screen = None

        stacktrace = None

        end_time = time.time() + self._timeout

        while True:

            try:

                value = method(self._driver)

                if value:

                    return value

            except self._ignored_exceptions as exc:

                screen = getattr(exc, 'screen', None)

                stacktrace = getattr(exc, 'stacktrace', None)

            time.sleep(self._poll)

            if time.time() > end_time:

                break

        raise TimeoutException(message, screen, stacktrace)