devbox
Monodyee
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

pywinauto核心代码理解_raise elementnotfounderror(kwargs)

作者：Monodyee | 2024-02-21 00:36:40

赞

踩

raise elementnotfounderror(kwargs)
  1.     def __getattribute__(self, attr_name):
  2.         """
  3.         Attribute access for this class
  5.         If we already have criteria for both dialog and control then
  6.         resolve the control and return the requested attribute.
  8.         If we have only criteria for the dialog but the attribute
  9.         requested is an attribute of DialogWrapper then resolve the
  10.         dialog and return the requested attribute.
  12.         Otherwise delegate functionality to :func:`__getitem__` - which
  13.         sets the appropriate criteria for the control.
  14.         """
  15.         allow_magic_lookup = object.__getattribute__(self, "allow_magic_lookup")  # Beware of recursions here!
  16.         if not allow_magic_lookup:
  17.             try:
  18.                 return object.__getattribute__(self, attr_name)
  19.             except AttributeError:
  20.                 wrapper_object = self.wrapper_object() # 这里是重点，需要看对应函数的实现代码
  21.                 try:
  22.                     return getattr(wrapper_object, attr_name)
  23.                 except AttributeError:
  24.                     message = (
  25.                         'Attribute "%s" exists neither on %s object nor on'
  26.                         'targeted %s element wrapper (typo? or set allow_magic_lookup to True?)' %
  27.                         (attr_name, self.__class__, wrapper_object.__class__))
  28.                     raise AttributeError(message)
  29.  
  30.         if attr_name in ['__dict__', '__members__', '__methods__', '__class__', '__name__']:
  31.             return object.__getattribute__(self, attr_name)
  32.  
  33.         if attr_name in dir(self.__class__):
  34.             return object.__getattribute__(self, attr_name)
  35.  
  36.         if attr_name in self.__dict__:
  37.             return self.__dict__[attr_name]
  38.  
  39.         # if we already have 2 levels of criteria (dlg, control)
  40.         # this third must be an attribute so resolve and get the
  41.         # attribute and return it
  42.         if len(self.criteria) >= 2:  # FIXME - this is surprising
  43.  
  44.             ctrls = self.__resolve_control(self.criteria)
  45.  
  46.             try:
  47.                 return getattr(ctrls[-1], attr_name)
  48.             except AttributeError:
  49.                 return self.child_window(best_match=attr_name)
  50.         else:
  51.             # FIXME - I don't get this part at all, why is it win32-specific and why not keep the same logic as above?
  52.             # if we have been asked for an attribute of the dialog
  53.             # then resolve the window and return the attribute
  54.             desktop_wrapper = self.backend.generic_wrapper_class(self.backend.element_info_class())
  55.             need_to_resolve = (len(self.criteria) == 1 and hasattr(desktop_wrapper, attr_name))
  56.             if hasattr(self.backend, 'dialog_class'):
  57.                 need_to_resolve = need_to_resolve and hasattr(self.backend.dialog_class, attr_name)
  58.             # Probably there is no DialogWrapper for another backend
  59.  
  60.             if need_to_resolve:
  61.                 ctrls = self.__resolve_control(self.criteria)
  62.                 return getattr(ctrls[-1], attr_name)
  63.  
  64.         # It is a dialog/control criterion so let getitem
  65.         # deal with it
  66.         return self[attr_name]
  1.     def __get_ctrl(self, criteria_):
  2.         """Get a control based on the various criteria"""
  3.         # make a copy of the criteria
  4.         criteria = [crit.copy() for crit in criteria_]
  5.         # find the dialog
  6.         if 'backend' not in criteria[0]:
  7.             criteria[0]['backend'] = self.backend.name
  8.         if self.app is not None:
  9.             # find_elements(...) accepts only "process" argument
  10.             criteria[0]['process'] = self.app.process
  11.             del criteria[0]['app']
  12.         dialog = self.backend.generic_wrapper_class(findwindows.find_element(**criteria[0]))
  13.  
  14.         ctrls = []
  15.         # if there is only criteria for a dialog then return it
  16.         if len(criteria) > 1:
  17.             # so there was criteria for a control, add the extra criteria
  18.             # that are required for child controls
  19.             previous_parent = dialog.element_info
  20.             for ctrl_criteria in criteria[1:]:
  21.                 ctrl_criteria["top_level_only"] = False
  22.                 if "parent" not in ctrl_criteria:
  23.                     ctrl_criteria["parent"] = previous_parent
  24.  
  25.                 if isinstance(ctrl_criteria["parent"], WindowSpecification):
  26.                     ctrl_criteria["parent"] = ctrl_criteria["parent"].wrapper_object()
  27.  
  28.                 # resolve the control and return it
  29.                 if 'backend' not in ctrl_criteria:
  30.                     ctrl_criteria['backend'] = self.backend.name
  31.                 ctrl = self.backend.generic_wrapper_class(findwindows.find_element(**ctrl_criteria))
  32.                 previous_parent = ctrl.element_info
  33.                 ctrls.append(ctrl)
  34.  
  35.         if ctrls:
  36.             return (dialog, ) + tuple(ctrls)
  37.         else:
  38.             return (dialog, )
  39.  
  40.     def __resolve_control(self, criteria, timeout=None, retry_interval=None):
  41.         """
  42.         Find a control using criteria
  44.         * **criteria** - a list that contains 1 or 2 dictionaries
  46.              1st element is search criteria for the dialog
  48.              2nd element is search criteria for a control of the dialog
  50.         * **timeout** -  maximum length of time to try to find the controls (default 5)
  51.         * **retry_interval** - how long to wait between each retry (default .2)
  52.         """
  53.         if timeout is None:
  54.             timeout = Timings.window_find_timeout
  55.         if retry_interval is None:
  56.             retry_interval = Timings.window_find_retry
  57.  
  58.         try:
  59.             ctrl = wait_until_passes(
  60.                 timeout,
  61.                 retry_interval,
  62.                 self.__get_ctrl, # 传入了一个函数接口
  63.                 (findwindows.ElementNotFoundError,
  64.                  findbestmatch.MatchError,
  65.                  controls.InvalidWindowHandle,
  66.                  controls.InvalidElement),
  67.                 criteria)
  68.  
  69.         except TimeoutError as e:
  70.             raise e.original_exception
  71.  
  72.         return ctrl
  73.  
  74.     def wrapper_object(self):
  75.         """Allow the calling code to get the HwndWrapper object"""
  76.         ctrls = self.__resolve_control(self.criteria)
  77.         return ctrls[-1]
  1. #=========================================================================
  2. def wait_until_passes(timeout,
  3.                       retry_interval,
  4.                       func,
  5.                       exceptions=(Exception),
  6.                       *args, **kwargs):
  7.     """
  8.     Wait until ``func(*args, **kwargs)`` does not raise one of the exceptions
  10.     * **timeout**  how long the function will try the function
  11.     * **retry_interval**  how long to wait between retries
  12.     * **func** the function that will be executed
  13.     * **exceptions**  list of exceptions to test against (default: Exception)
  14.     * **args** optional arguments to be passed to func when called
  15.     * **kwargs** optional keyword arguments to be passed to func when called
  17.     Returns the return value of the function
  18.     If the operation times out then the original exception raised is in
  19.     the 'original_exception' attribute of the raised exception.
  21.     e.g. ::
  23.         try:
  24.             # wait a maximum of 10.5 seconds for the
  25.             # window to be found in increments of .5 of a second.
  26.             # P.int a message and re-raise the original exception if never found.
  27.             wait_until_passes(10.5, .5, self.Exists, (ElementNotFoundError))
  28.         except TimeoutError as e:
  29.             print("timed out")
  30.             raise e.
  31.     """
  32.     start = timestamp()
  33.  
  34.     # keep trying until the timeout is passed
  35.     while True:
  36.         try:
  37.             # Call the function with any arguments
  38.             func_val = func(*args, **kwargs)
  39.  
  40.             # if no exception is raised then we are finished
  41.             break
  42.  
  43.         # An exception was raised - so wait and try again
  44.         except exceptions as e:
  45.  
  46.             # find out how much of the time is left
  47.             time_left = timeout - (timestamp() - start)
  48.  
  49.             # if we have to wait some more
  50.             if time_left > 0:
  51.                 # wait either the retry_interval or else the amount of
  52.                 # time until the timeout expires (whichever is less)
  53.                 time.sleep(min(retry_interval, time_left))
  54.  
  55.             else:
  56.                 # Raise a TimeoutError - and put the original exception
  57.                 # inside it
  58.                 err = TimeoutError()
  59.                 err.original_exception = e
  60.                 raise err
  61.  
  62.     # return the function value
  63.     return func_val
  1. #=========================================================================
  2. def find_element(**kwargs):
  3.     """
  4.     Call find_elements and ensure that only one element is returned
  6.     Calls find_elements with exactly the same arguments as it is called with
  7.     so please see :py:func:`find_elements` for the full parameters description.
  8.     """
  9.     elements = find_elements(**kwargs)
  10.  
  11.     if not elements:
  12.         raise ElementNotFoundError(kwargs)
  13.  
  14.     if len(elements) > 1:
  15.         exception = ElementAmbiguousError(
  16.             "There are {0} elements that match the criteria {1}".format(
  17.                 len(elements),
  18.                 six.text_type(kwargs),
  19.             )
  20.         )
  21.  
  22.         exception.elements = elements
  23.         raise exception
  24.  
  25.     return elements[0]

以下是我的理解：
1. 通过child_window()无条件的返回了一个pywinauto.application.WindowSpecification对象，这个对象只是封装了对应的查找条件，拿着这个返回对象还不能知道是否成功查找到窗口；

2. WindowSpecification对象获取其wapper_object()时才开始真正查找。wrapper_object() -> _resolve_control() -> wait_until_passes() -> _get_ctrl() -> findwindows.find_element()
3. wait_until_passes()中使用了总超时时间和重试间隔，当总时间超时时会抛出Timeout异常。如果__get_ctrl()返回了正常值就立即返回;
4.wait_until_passes会捕获_resolve_control()中指定的(findwindows.ElementNotFoundError,
                 findbestmatch.MatchError,
                 controls.InvalidWindowHandle,
                 controls.InvalidElement)几种类型的异常，当出现这些异常时会继续进行重试。
 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Monodyee/article/detail/121325
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号