def _wnd_filter(wlist, single=False, negative=False, none=False, number=None, attributes={}, _assert=False, attr_dict=None):
"""
Wnd Filter | <list> | params and attributes
Filters windows from a list by attributes.
:return List (or a single window if "single" is given).
"""
li = list(wlist)
attr_filters = attributes.get('wait', [])
for attr, params in attr_filters:
li = [item for item in li if attr_dict.action(item, attr, 'wait', params)]
if negative:
li = filter(lambda v: v not in li, wlist)
ok, res, msg = result_modifier(li, src_list=wlist, none=none, single=single, number=number)
#logging.warning("FILTERING: %s" % repr((ok, res, msg, wlist)))
if ok:
return res
if _assert:
raise IronbotException('Wnd Filter failed: %s' % msg)
logging.warning('Wnd Filter failed: %s' % msg)
return res
def proc_filter(pli, none=False, number=None, single=False, _assert=False, negative=False, attributes={}, attr_dict=None):
"""
Proc Filter | <list> | named params & attributes
Filters a process list using attributes. The only action is "wait" (defaut).
:return: A list of processes or False (e.g. in case of "none" flag) if "single" flag is not specified.
A single process object or False otherwise.
If "assert" flag is present, False is never returned, the keyword fails instead.
"""
li = list(pli)
attr_filters = attributes.get('wait', [])
for attr, params in attr_filters:
li = [item for item in li if attr_dict.action(item, attr, 'wait', params)]
if negative:
li = filter(lambda v: v not in li, pli)
ok, li, msg = result_modifier(li, none=none, single=single, number=number)
if not isinstance(pli, list) and isinstance(li, list):
if len(li):
li = li[0]
else:
li = None
if not ok:
if _assert:
logging.error('Proc Filter failed: %s' % msg)
raise IronbotException('Proc Filter failed: %s' % msg)
logging.warning('Proc Filter failed: %s' % msg)
return li
def ctl_get(c_type, parent=None, src_li=None, timeout=Delay('0s'), number=None, negative=False, single=False, none=False, _assert=False, index=None, attributes={}, attr_dict=None):
ct = CONTROL_TYPES.get(c_type)
if ct:
criteria = SearchCriteria.ByControlType(CONTROL_TYPES.get(c_type))
else:
criteria = SearchCriteria.All
attr_filters = attributes.get('wait', [])
for _ in waiting_iterator(timeout):
if parent:
#logging.warning(repr(parent) + repr(dir(parent)))
if isinstance(parent, list):
raise IronbotException("Ctl Get: 'parent' should contain a single window, not a list (check if there is a 'single' or 'index' parameter when searching for that window).")
mult = parent.GetMultiple(criteria)
li = [elem for elem in mult]
elif src_li:
li = list(src_li)
for attr, params in attr_filters:
li = [item for item in li if attr_dict.action(item, attr, 'wait', params)]
if negative:
li = filter(lambda v: v not in li, src_li)
ok, res, msg = result_modifier(li, src_list=src_li, single=single, none=none, number=number, index=index)
if ok:
return res
if _assert:
logging.error('Ctl Get failed: %s' % msg)
raise IronbotException('Ctl Get failed: %s' % msg)
logging.warning('Ctl Get failed: %s' % msg)
return res
def ctl_get(c_type, parent=None, src_li=None, timeout=Delay('0s'), number=None, negative=False, single=False, none=False, _assert=False, index=None, attributes={}, attr_dict=None):
"""
Ctl Get | <c_type> [| <parent>/<src_li> ] | attributes & paramsa
:param c_type: control type name (all, button, edit, menu, list, listitem, radio, radiobutton,
checkbox, tab, tree, treenode, toolbar)
:param parent: an optional named parameter, parent window. Incompatible with src_li
:param src_li: an optional named parameter, a list of controls to filter.
:param negative: inverts filtering
:return:
"""
ct = CONTROL_TYPES.get(c_type)
if ct:
criteria = SearchCriteria.ByControlType(CONTROL_TYPES.get(c_type))
else:
criteria = SearchCriteria.All
attr_filters = attributes.get('wait', [])
for _ in waiting_iterator(timeout):
if parent:
#logging.warning(repr(parent) + repr(dir(parent)))
if isinstance(parent, list):
raise IronbotException("Ctl Get: 'parent' should contain a single window, not a list (check if there is a 'single' or 'index' parameter when searching for that window).")
mult = parent.GetMultiple(criteria)
li = [elem for elem in mult]
elif src_li:
li = list(src_li)
for attr, params in attr_filters:
li = [item for item in li if attr_dict.action(item, attr, 'wait', params)]
if negative:
li = filter(lambda v: v not in li, src_li)
ok, res, msg = result_modifier(li, src_list=src_li, single=single, none=none, number=number, index=index)
if ok:
return res
if _assert:
logging.error('Ctl Get failed: %s' % msg)
raise IronbotException('Ctl Get failed: %s' % msg)
logging.warning('Ctl Get failed: %s' % msg)
return res
def app_state(app, running=True, timeout=Delay('0s'), any=False, all=False, single=False, none=False, _assert=False, number=None):
"""
App State | <app> | params
:param app: required, positional -- an application object;
:param running: an optional flag -- the result is True if the app is running;
:param not_running: an optional flag -- the result is True if the app is not running;
:param kill: an optional flag -- same as not_running plus kills the app after waiting;
:param assert: an optional flag -- fail keyword on failure;
:param timeout: optional, followed by a delay value, e.g. *10s -- wait for the desired state.
:return: True if the app state at the end of waiting is as desired, otherwise False
"""
src_app = app
if not isinstance(src_app, list):
app = [app]
kill = running is None
running = bool(running)
prefer_bool = all or any or single or none or not isinstance(src_app, list)
for _ in waiting_iterator(timeout):
res_list = []
for a in app:
res_list.append(bool(a.HasExited) != bool(running))
ok, res, msg = result_modifier(res_list, src_list=src_app, any=any, all=all, single=single, none=none, number=number, prefer_bool=prefer_bool)
if ok:
break
if kill:
for a in app:
if not a.HasExited:
logging.warning('Killing an application')
a.Dispose()
if ok:
return res
if _assert:
logging.error('App State failed: %s' % msg)
raise IronbotTimeoutException('App State failed: %s' % msg)
logging.warning('App State failed: %s' % msg)
return res
def proc_filter(pli, none=False, number=None, single=False, _assert=False, negative=False, attributes={}, attr_dict=None):
li = list(pli)
attr_filters = attributes.get('wait', [])
for attr, params in attr_filters:
li = [item for item in li if attr_dict.action(item, attr, 'wait', params)]
if negative:
li = filter(lambda v: v not in li, pli)
ok, li, msg = result_modifier(li, none=none, single=single, number=number)
if not isinstance(pli, list) and isinstance(li, list):
if len(li):
li = li[0]
else:
li = None
if not ok:
if _assert:
logging.error('Proc Filter failed: %s' % msg)
raise IronbotException('Proc Filter failed: %s' % msg)
logging.warning('Proc Filter failed: %s' % msg)
return li
