# from modula import * 表示默认导入modula中所有不以下划线开头的成员

 from _logging import _LoggingKeywords

 from _runonfailure import _RunOnFailureKeywords

 from _browsermanagement import _BrowserManagementKeywords

 from _element import _ElementKeywords

 from _tableelement import _TableElementKeywords

 from _formelement import _FormElementKeywords

 from _selectelement import _SelectElementKeywords

 from _javascript import _JavaScriptKeywords

 from _cookie import _CookieKeywords

 from _screenshot import _ScreenshotKeywords

 from _waiting import _WaitingKeywords

 # 定义了__all__后, 表示只导出以下列表中的成员

 __all__ = [

     "_LoggingKeywords",

     "_RunOnFailureKeywords",

     "_BrowserManagementKeywords",

     "_ElementKeywords",

     "_TableElementKeywords",

     "_FormElementKeywords",

     "_SelectElementKeywords",

     "_JavaScriptKeywords",

     "_CookieKeywords",

     "_ScreenshotKeywords",

     "_WaitingKeywords"

 ]

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

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

3         maxtime = time.time() + timeout

4         while True:

5             timeout_error = wait_func(*args)

6             if not timeout_error: return  #如果wait_func()无返回,进行超时判断;否则返回wait_func()执行结果

7             if time.time() > maxtime:     #超时强制抛出timeout_error异常

8                 raise AssertionError(timeout_error)

9             time.sleep(0.2)

1     def _wait_until(self, timeout, error, function, *args):

2         error = error.replace('<TIMEOUT>', self._format_timeout(timeout))

3         def wait_func():

4             return None if function(*args) else error

5         self._wait_until_no_error(timeout, wait_func)

1     def wait_for_condition(self, condition, timeout=None, error=None):

2         if not error:

3             error = "Condition '%s' did not become true in <TIMEOUT>" % condition

4         self._wait_until(timeout, error, lambda: self._current_browser().execute_script(condition) == True)

 class KeywordGroupMetaClass(type):

     def __new__(cls, clsname, bases, dict):

         if decorator:

             for name, method in dict.items():

                 if not name.startswith('_') and inspect.isroutine(method):

                     dict[name] = decorator(_run_on_failure_decorator, method)

         return type.__new__(cls, clsname, bases, dict)

     def register_keyword_to_run_on_failure(self, keyword):

         old_keyword = self._run_on_failure_keyword

         old_keyword_text = old_keyword if old_keyword is not None else "No keyword"

         new_keyword = keyword if keyword.strip().lower() != "nothing" else None

         new_keyword_text = new_keyword if new_keyword is not None else "No keyword"

         self._run_on_failure_keyword = new_keyword

         self._info('%s will be run on failure.' % new_keyword_text)

         return old_keyword_text

     def __init__(self):

         strategies = {

             'identifier': self._find_by_identifier,

             'id': self._find_by_id,

             'name': self._find_by_name,

             'xpath': self._find_by_xpath,

             'dom': self._find_by_dom,

             'link': self._find_by_link_text,

             'partial link': self._find_by_partial_link_text,

             'css': self._find_by_css_selector,

             'jquery': self._find_by_sizzle_selector,

             'sizzle': self._find_by_sizzle_selector,

             'tag': self._find_by_tag_name,

             'scLocator': self._find_by_sc_locator,

             'default': self._find_by_default

         }

         self._strategies = NormalizedDict(initial=strategies, caseless=True, spaceless=True)

         self._default_strategies = strategies.keys()

     def find(self, browser, locator, tag=None):

         assert browser is not None

         assert locator is not None and len(locator) > 0

         (prefix, criteria) = self._parse_locator(locator) # 从locator对象中提取prefix和criteria

         prefix = 'default' if prefix is None else prefix

         strategy = self._strategies.get(prefix) # self._strategies对象的属性石robot.util中的NormalizeDict(标准化字典)

         if strategy is None:

             raise ValueError("Element locator with prefix '" + prefix + "' is not supported")

         (tag, constraints) = self._get_tag_and_constraints(tag)

         return strategy(browser, criteria, tag, constraints) # 返回strategy的find结果