def not_list_or_tuple(param, exc_info=None):
"""
Fails if param is not a list or tuple
"""
if not is_list_or_tuple(param):
if exc_info:
raise exc_info
raise ValueError("{} is not list or tuple".format(
get_name_from_param(param)))
def add_browsers(self, *renders_info):
if len(renders_info) == 1 and is_list_or_tuple(renders_info[0]):
renders_info = renders_info[0]
for render_info in renders_info:
try:
self.add_browser(render_info)
except TypeError as e:
raise_from(TypeError("Wrong argument in .add_browsers()"), e)
return self
def __init__(self, target):
# type: (Union[Region, Text, BySelector, Locator]) -> None
if isinstance(target, string_types):
self.target = TargetPath.region(target)
elif is_list_or_tuple(target):
self.target = TargetPath.region(*target)
else:
self.target = target
self._hint = None # type: Optional[Text]
self._language = "eng" # type: Optional[Text]
self._min_match = None # type: Optional[float]
def _floating_provider_from(self, region, bounds):
if is_webelement(region):
return FloatingRegionByElement(region, bounds)
elif isinstance(region, string_types):
return FloatingRegionBySelector(TargetPath.region(region), bounds)
elif is_list_or_tuple(region):
return FloatingRegionBySelector(TargetPath.region(*region), bounds)
elif isinstance(region, Locator):
return FloatingRegionBySelector(region, bounds)
return super(SeleniumCheckSettings,
self)._floating_provider_from(region, bounds)
def _region_provider_from(self, region, method_name, padding):
if isinstance(region, string_types):
return RegionBySelector(TargetPath.region(region), padding)
elif is_list_or_tuple(region):
return RegionBySelector(TargetPath.region(*region), padding)
elif isinstance(region, Locator):
return RegionBySelector(region, padding)
elif is_webelement(region):
return RegionByElement(region, padding)
return super(SeleniumCheckSettings,
self)._region_provider_from(region, method_name, padding)
def scroll_root_element(self, element_or_selector): # noqa
if isinstance(element_or_selector, string_types):
self._set_scroll_root_selector(
TargetPath.region(element_or_selector))
elif is_list_or_tuple(element_or_selector):
self._set_scroll_root_selector(
TargetPath.region(*element_or_selector))
elif isinstance(element_or_selector, Locator):
self._set_scroll_root_selector(element_or_selector)
elif is_webelement(element_or_selector):
self._set_scroll_root_element(element_or_selector)
else:
raise TypeError("Unsupported type of scroll root element")
return self
def _accessibility_provider_from(self, region, accessibility_region_type):
if is_webelement(region):
return AccessibilityRegionByElement(region,
accessibility_region_type)
elif isinstance(region, string_types):
return AccessibilityRegionBySelector(TargetPath.region(region),
accessibility_region_type)
elif is_list_or_tuple(region):
return AccessibilityRegionBySelector(TargetPath.region(*region),
accessibility_region_type)
elif isinstance(region, Locator):
return AccessibilityRegionBySelector(region,
accessibility_region_type)
return super(SeleniumCheckSettings, self)._accessibility_provider_from(
region, accessibility_region_type)
def region(self, region): # noqa
# type:(...) -> SeleniumCheckSettings
if isinstance(region, Region):
self.values.target_region = region
elif is_list_or_tuple(region):
self.values.target_selector = TargetPath.region(*region)
elif isinstance(region, string_types):
self.values.target_selector = TargetPath.region(region)
elif isinstance(region, Locator):
self.values.target_selector = region
elif is_webelement(region):
self.values.target_element = region
else:
raise TypeError(
"region method called with argument of unknown type!")
return self
def frame(self, frame): # noqa
# type:(...) -> SeleniumCheckSettings
fl = FrameLocator()
if isinstance(frame, int):
fl.frame_index = frame
elif isinstance(frame, string_types):
fl.frame_name_or_id = frame
elif is_webelement(frame):
fl.frame_element = frame
elif is_list_or_tuple(frame):
fl.frame_selector = TargetPath.frame(*frame)
elif isinstance(frame, Locator):
fl.frame_selector = frame
else:
raise TypeError(
"frame method called with argument of unknown type!")
self.values.frame_chain.append(fl)
return self
def _clean_names(names):
argument_guard.not_list_or_tuple(names)
if len(names) == 1 and is_list_or_tuple(names[0]):
names = names[0]
argument_guard.are_(names, klass=basestring)
return names
