mops 3.3.2__tar.gz → 3.4.0__tar.gz

{mops-3.3.2 → mops-3.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: mops
-Version: 3.3.2
+Version: 3.4.0
 Summary: Wrapper of Selenium, Appium and Playwright with single API
 Author-email: Podolian Vladimir <vladimir.podolyan64@gmail.com>
 License: MIT

{mops-3.3.2 → mops-3.4.0}/mops/__init__.py

@@ -1,2 +1,2 @@
-__version__ = '3.3.2'
+__version__ = '3.4.0'
 __project_name__ = 'mops'

{mops-3.3.2 → mops-3.4.0}/mops/abstraction/element_abc.py

@@ -24,10 +24,32 @@ if TYPE_CHECKING:
 
 class ElementABC(MixinABC, ABC):
 
-    locator: Union[Locator, str]
-    name: str = ''
-    parent: Union[Any, bool, None] = None
-    wait: Optional[bool] = None
+    name: str
+    parent: Union[Any, bool, None]
+    wait: Optional[bool]
+
+    _locator: Union[str, Locator]
+    _locator_type: Union[str, None] = None
+
+    @property
+    def locator(self) -> str:
+        raise NotImplementedError()
+
+    @locator.setter
+    def locator(self, value: Union[Locator, str]) -> None:
+        raise NotImplementedError()
+
+    @property
+    def locator_type(self) -> str:
+        raise NotImplementedError()
+
+    @locator_type.setter
+    def locator_type(self, value: str) -> None:
+        raise NotImplementedError()
+
+    @property
+    def log_locator(self) -> str:
+        raise NotImplementedError()
 
     @property
     def element(self) -> Union[SeleniumWebElement, AppiumWebElement, PlayWebElement]:
@@ -925,3 +947,11 @@ class ElementABC(MixinABC, ABC):
         :return: A list of wrapped :class:`Element` objects.
         """
         raise NotImplementedError()
+
+    def _set_locator(self) -> None:
+        """
+        Set locator for current object
+
+        :return: :obj:`None`
+        """
+        raise NotImplementedError()

{mops-3.3.2 → mops-3.4.0}/mops/base/driver_wrapper.py

@@ -21,7 +21,7 @@ from mops.selenium.driver.mobile_driver import MobileDriver
 from mops.selenium.driver.web_driver import WebDriver
 from mops.exceptions import DriverWrapperException
 from mops.mixins.internal_mixin import InternalMixin
-from mops.utils.internal_utils import get_attributes_from_object, get_child_elements_with_names
+from mops.utils.internal_utils import extract_named_objects, get_attributes_from_object
 from mops.utils.logs import Logging, LogLevel
 
 
@@ -130,7 +130,7 @@ class DriverWrapper(InternalMixin, Logging, DriverWrapperABC):
         else:
             cls = super().__new__(type(f'ShadowDriverWrapper', (cls, ), get_attributes_from_object(cls)))  # noqa
 
-        for name, _ in get_child_elements_with_names(cls, bool).items():
+        for name, _ in extract_named_objects(cls, bool).items():
             setattr(cls, name, False)
 
         return cls
@@ -348,7 +348,11 @@ class DriverWrapper(InternalMixin, Logging, DriverWrapperABC):
             self.is_selenium = True
             self._base_cls = WebDriver
         else:
-            raise DriverWrapperException(f'Cant specify {self.__class__.__name__}')
+            raise DriverWrapperException(
+                f'Cannot initialize {self.__class__.__name__}: '
+                f'unsupported driver type "{type(source_driver).__name__}". '
+                f'Expected Playwright, Appium or Selenium driver instance'
+            )
 
         self._set_static(self._base_cls)
         self._base_cls.__init__(self, driver_container=self.__driver_container)

{mops-3.3.2 → mops-3.4.0}/mops/base/element.py

@@ -1,7 +1,10 @@
 from __future__ import annotations
 
+import functools
 import time
+from abc import ABCMeta
 from copy import copy
+from functools import cached_property
 from typing import Union, List, Type, Tuple, Optional, TYPE_CHECKING
 
 from PIL.Image import Image
@@ -33,10 +36,8 @@ from mops.utils.internal_utils import (
     WAIT_EL,
     is_target_on_screen,
     initialize_objects,
-    get_child_elements_with_names,
-    safe_getattribute,
+    extract_named_objects,
     set_parent_for_attr,
-    is_page,
     QUARTER_WAIT_EL,
 )
 from mops.utils.decorators import wait_condition, wait_continuous
@@ -45,7 +46,22 @@ if TYPE_CHECKING:
     from mops.base.group import Group
 
 
-class Element(DriverMixin, InternalMixin, Logging, ElementABC):
+class ElementMeta(ABCMeta):
+    def __new__(mcs, name, bases, namespace, **kwargs):
+        cls = super().__new__(mcs, name, bases, namespace, **kwargs)
+        orig_init = cls.__init__
+
+        @functools.wraps(orig_init)
+        def wrapped_init(self, *args, **kw):
+            orig_init(self, *args, **kw)
+            if type(self) is cls and getattr(self, '_initialized', False):
+                self._modify_sub_elements()
+
+        cls.__init__ = wrapped_init
+        return cls
+
+
+class Element(DriverMixin, InternalMixin, Logging, ElementABC, metaclass=ElementMeta):
     """
     Represents a UI element that serves as a central component for interaction.
 
@@ -54,18 +70,23 @@ class Element(DriverMixin, InternalMixin, Logging, ElementABC):
     It dynamically adapts to different driver types (Playwright, Appium, Selenium)
     and provides a unified interface for UI interactions.
     """
+    _object: str = 'element'
+    _initialized: bool = False
+    _is_locator_configured: bool = False
+    _base_cls: Type[PlayElement, MobileElement, WebElement]
 
     source_locator: Union[Locator, str]
 
-    _object = 'element'
-    _base_cls: Type[PlayElement, MobileElement, WebElement]
-    driver_wrapper: DriverWrapper
-
     def __new__(cls, *args, **kwargs):
         instance = super(Element, cls).__new__(cls)
         set_instance_frame(instance)
         return instance
 
+    def __copy__(self):
+        new = object.__new__(self.__class__)
+        new.__dict__.update(self.__dict__)
+        return new
+
     def __repr__(self):
         return self._repr_builder()
 
@@ -73,15 +94,6 @@ class Element(DriverMixin, InternalMixin, Logging, ElementABC):
         self.__full_init__(driver_wrapper=get_driver_wrapper_from_object(driver_wrapper))
         return self
 
-    def __getattribute__(self, item):
-        if 'element' in item and not safe_getattribute(self, '_initialized'):
-            raise NotInitializedException(
-                f'{repr(self)} object is not initialized. '
-                'Try to initialize base object first or call it directly as a method'
-            )
-
-        return safe_getattribute(self, item)
-
     def __init__(
             self,
             locator: Union[Locator, str],
@@ -108,24 +120,15 @@ class Element(DriverMixin, InternalMixin, Logging, ElementABC):
          an object containing it to be used for this element.
         :type driver_wrapper: typing.Union[DriverWrapper, typing.Any]
         """
-        self._validate_inheritance()
-
-        if parent:
-            if not isinstance(parent, (bool, Element)):
-                error = (f'The given "parent" arg of "{self.name}" should take an Element/Group '
-                         f'object or False for skip. Get {parent}')
-                raise ValueError(error)
+        self.driver_wrapper = get_driver_wrapper_from_object(driver_wrapper)
 
-        self.locator = locator
         self.source_locator = locator
-        self.name = name if name else locator
+        self.locator = locator
+        self.name = name or locator
         self.parent = parent
         self.wait = wait
-        self.driver_wrapper = get_driver_wrapper_from_object(driver_wrapper)
 
-        self._init_locals = getattr(self, '_init_locals', locals())
         self._safe_setter('__base_obj_id', id(self))
-        self._initialized = False
 
         if self.driver_wrapper:
             self.__full_init__(driver_wrapper)
@@ -133,11 +136,10 @@ class Element(DriverMixin, InternalMixin, Logging, ElementABC):
     def __full_init__(self, driver_wrapper: Any = None):
         self._driver_wrapper_given = bool(driver_wrapper)
 
-        if self._driver_wrapper_given and driver_wrapper != self.driver_wrapper:
+        if driver_wrapper and driver_wrapper != self.driver_wrapper:
             self.driver_wrapper = get_driver_wrapper_from_object(driver_wrapper)
 
         self._modify_object()
-        self._modify_children()
 
         if not self._initialized:
             self.__init_base_class__()
@@ -148,19 +150,57 @@ class Element(DriverMixin, InternalMixin, Logging, ElementABC):
 
         :return: None
         """
-        if isinstance(self.driver, PlaywrightDriver):
+        if self._driver_is_instance(PlaywrightDriver):
             self._base_cls = PlayElement
-        elif isinstance(self.driver, AppiumDriver):
+        elif self._driver_is_instance(AppiumDriver):
             self._base_cls = MobileElement
-        elif isinstance(self.driver, SeleniumDriver):
+        elif self._driver_is_instance(SeleniumDriver):
             self._base_cls = WebElement
         else:
-            raise DriverWrapperException(f'Cant specify {self.__class__.__name__}')
+            raise DriverWrapperException(
+                f'Cannot initialize {self.__class__.__name__}: '
+                f'unsupported driver type "{type(self.driver).__name__}". '
+                f'Expected Playwright, Appium or Selenium driver instance'
+            )
 
         self._set_static(self._base_cls)
         self._base_cls.__init__(self)
         self._initialized = True
 
+    @property
+    def locator(self) -> str:
+        if not self._is_locator_configured:
+            self._set_locator()
+
+        return self._locator
+
+    @locator.setter
+    def locator(self, value: Union[Locator, str]) -> None:
+        self._log_locator = value
+        self._locator = value
+
+    @property
+    def locator_type(self) -> str:
+        if not self._is_locator_configured:
+            self._set_locator()
+
+        return self._locator_type
+
+    @locator_type.setter
+    def locator_type(self, value: str) -> None:
+        self._locator_type = value
+
+    @property
+    def log_locator(self) -> str:
+        if not self._is_locator_configured:
+            self._set_locator()
+
+        return self._log_locator
+
+    @log_locator.setter
+    def log_locator(self, value: str) -> None:
+        self._log_locator = value
+
     # Following methods works same for both Selenium/Appium and Playwright APIs using internal methods
 
     # Elements interaction
@@ -955,31 +995,41 @@ class Element(DriverMixin, InternalMixin, Logging, ElementABC):
             wrapped_object: Any = copy(self)
             wrapped_object.element = element
             wrapped_object._wrapped = True
-            set_parent_for_attr(wrapped_object, Element, with_copy=True)
+            wrapped_object.sub_elements = dict(self.sub_elements)
+            set_parent_for_attr(wrapped_object, with_copy=True)
             wrapped_elements.append(wrapped_object)
 
         return wrapped_elements
 
-    def _modify_children(self):
+    def _modify_sub_elements(self) -> None:
         """
-        Initializing of attributes with  type == Element.
+        Initializing of attributes with type == Element.
         Required for classes with base == Element.
+
+        :return: :obj:`None`
         """
-        initialize_objects(self, get_child_elements_with_names(self, Element), Element)
+        self.sub_elements = {}
+
+        if type(self) is not self._element_cls:
+            self.sub_elements = extract_named_objects(self, Element)
+            initialize_objects(self, self.sub_elements)
 
-    def _modify_object(self):
+    def _modify_object(self) -> None:
         """
         Modify current object if driver_wrapper is not given. Required for Page that placed into functions:
         - sets driver from previous object
+
+        :return: :obj:`None`
         """
         if not self._driver_wrapper_given:
             PreviousObjectDriver().set_driver_from_previous_object(self)
 
-    def _validate_inheritance(self):
-        cls = self.__class__
-        mro = cls.__mro__
+    @cached_property
+    def _element_cls(self) -> Type[Element]:
+        """
+        Returns the `Element` class.
+        This can be overridden for performance optimizations.
 
-        for item in mro:
-            if is_page(item):
-                raise TypeError(
-                    f"You cannot make an inheritance for {cls.__name__} from both Element/Group and Page objects")
+        :return: :obj:`typing.Type` [:class:`Element`]
+        """
+        return Element

{mops-3.3.2 → mops-3.4.0}/mops/base/group.py

@@ -1,15 +1,14 @@
 from __future__ import annotations
 
-from typing import Any, Union, List, Optional
+from typing import Any, Union, Optional
 
 from mops.base.driver_wrapper import DriverWrapper
 from mops.base.element import Element
 from mops.mixins.objects.locator import Locator
 from mops.utils.internal_utils import (
     set_parent_for_attr,
-    get_child_elements,
     initialize_objects,
-    get_child_elements_with_names
+    extract_named_objects
 )
 
 
@@ -27,11 +26,7 @@ class Group(Element):
     This class provides functionality for handling element locators,
     initialization with respect to the driver, and managing sub-elements within the group.
     """
-
-    _object = 'group'
-
-    def __repr__(self):
-        return self._repr_builder()
+    _object: str = 'group'
 
     def __init__(
             self,
@@ -63,7 +58,6 @@ class Group(Element):
          an object containing it to be used for entire group.
         :type driver_wrapper: typing.Union[DriverWrapper, typing.Any]
         """
-        self._init_locals = locals()
         super().__init__(
             locator=locator,
             name=name,
@@ -72,11 +66,11 @@ class Group(Element):
             driver_wrapper=driver_wrapper,
         )
 
-    def _modify_children(self) -> None:
+    def _modify_sub_elements(self) -> None:
         """
         Initializing of attributes with type == Group/Element.
         Required for classes with base == Group.
         """
-        initialize_objects(self, get_child_elements_with_names(self, Element), Element)
-        set_parent_for_attr(self, Element)
-        self.child_elements: List[Element] = get_child_elements(self, Element)
+        self.sub_elements = extract_named_objects(self, Element)
+        initialize_objects(self, self.sub_elements)
+        set_parent_for_attr(self)

{mops-3.3.2 → mops-3.4.0}/mops/base/page.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
-from typing import Union, Any, List, Type
+from functools import cached_property
+from typing import Union, Any, Type
 
 from playwright.sync_api import Page as PlaywrightDriver
 from appium.webdriver.webdriver import WebDriver as AppiumDriver
@@ -21,9 +22,7 @@ from mops.utils.previous_object_driver import PreviousObjectDriver, set_instance
 from mops.utils.internal_utils import (
     WAIT_PAGE,
     initialize_objects,
-    get_child_elements_with_names,
-    get_child_elements,
-    is_element_instance,
+    extract_named_objects,
 )
 
 
@@ -43,7 +42,9 @@ class Page(DriverMixin, InternalMixin, Logging, PageABC):
     _object = 'page'
     _base_cls: Type[PlayPage, MobilePage, WebPage]
 
-    anchor: Element
+    url: str
+    log_locator: Union[str, None] = None
+    locator_type: Union[str, None] = None
 
     def __new__(cls, *args, **kwargs):
         instance = super(Page, cls).__new__(cls)
@@ -70,25 +71,15 @@ class Page(DriverMixin, InternalMixin, Logging, PageABC):
          an object containing it to be used for entire page.
         :type driver_wrapper: typing.Union[DriverWrapper, typing.Any]
         """
-        self._validate_inheritance()
-
         self.driver_wrapper = get_driver_wrapper_from_object(driver_wrapper)
-        
-        self.anchor = Element(locator, name=name, driver_wrapper=self.driver_wrapper)
-        self.locator = self.anchor.locator
-        self.locator_type = self.anchor.locator_type
-        self.log_locator = self.anchor.log_locator
-        self.name = self.anchor.name
 
-        self.url = getattr(self, 'url', '')
+        self.locator = locator
+        self.name = name
 
-        self._init_locals = locals()
         self._modify_page_driver_wrapper(driver_wrapper)
-        self._modify_children()
+        self._modify_sub_elements()
         self._safe_setter('__base_obj_id', id(self))
 
-        self.page_elements: List[Element] = get_child_elements(self, Element)
-
         self.__init_base_class__()
 
     def __init_base_class__(self) -> None:
@@ -97,18 +88,37 @@ class Page(DriverMixin, InternalMixin, Logging, PageABC):
 
         :return: None
         """
-        if isinstance(self.driver, PlaywrightDriver):
+        if self._driver_is_instance(PlaywrightDriver):
             self._base_cls = PlayPage
-        elif isinstance(self.driver, AppiumDriver):
+        elif self._driver_is_instance(AppiumDriver):
             self._base_cls = MobilePage
-        elif isinstance(self.driver, SeleniumDriver):
+        elif self._driver_is_instance(SeleniumDriver):
             self._base_cls = WebPage
         else:
-            raise DriverWrapperException(f'Cant specify {Page.__name__}')
+            raise DriverWrapperException(
+                f'Cannot initialize {Page.__name__}: '
+                f'unsupported driver type "{type(self.driver).__name__}". '
+                f'Expected Playwright, Appium or Selenium driver instance'
+            )
 
         self._set_static(self._base_cls)
         self._base_cls.__init__(self)
 
+    @cached_property
+    def anchor(self) -> Element:
+        """
+        Return the anchor element of the page
+
+        :return: :base:`.Element`
+        """
+        anchor = Element(self.locator, name=self.name, driver_wrapper=self.driver_wrapper)
+        self.locator = anchor.locator
+        self.name = anchor.name
+        self.locator_type = anchor.locator_type
+        self.log_locator = anchor.log_locator
+
+        return anchor
+
     # Following methods works same for both Selenium/Appium and Playwright APIs using internal methods
 
     def reload_page(self, wait_page_load: bool = True) -> Page:
@@ -159,7 +169,7 @@ class Page(DriverMixin, InternalMixin, Logging, PageABC):
 
         self.anchor.wait_visibility(timeout=timeout, silent=True)
 
-        for element in self.page_elements:
+        for element in self.sub_elements.values():
             if getattr(element, 'wait') is False:
                 element.wait_hidden(timeout=timeout, silent=True)
             elif getattr(element, 'wait') is True:
@@ -179,7 +189,7 @@ class Page(DriverMixin, InternalMixin, Logging, PageABC):
         result = True
 
         if with_elements:
-            for element in self.page_elements:
+            for element in self.sub_elements.values():
                 if getattr(element, 'wait'):
                     result &= element.is_displayed(silent=True)
                     if not result:
@@ -187,17 +197,18 @@ class Page(DriverMixin, InternalMixin, Logging, PageABC):
 
         result &= self.anchor.is_displayed()
 
-        if self.url and with_url:
+        if with_url:
             result &= self.driver_wrapper.current_url == self.url
 
         return result
 
-    def _modify_children(self):
+    def _modify_sub_elements(self):
         """
         Initializing of attributes with type == Element.
         Required for classes with base == Page.
         """
-        initialize_objects(self, get_child_elements_with_names(self, Element), Element)
+        self.sub_elements = extract_named_objects(self, Element)
+        initialize_objects(self, self.sub_elements)
 
     def _modify_page_driver_wrapper(self, driver_wrapper: Any):
         """
@@ -206,12 +217,3 @@ class Page(DriverMixin, InternalMixin, Logging, PageABC):
         """
         if not driver_wrapper:
             PreviousObjectDriver().set_driver_from_previous_object(self)
-
-    def _validate_inheritance(self):
-        cls = self.__class__
-        mro = cls.__mro__
-
-        for item in mro:
-            if is_element_instance(item):
-                raise TypeError(
-                    f"You cannot make an inheritance for {cls.__name__} from both Page and Group/Element objects")

{mops-3.3.2 → mops-3.4.0}/mops/mixins/internal_mixin.py

@@ -4,8 +4,8 @@ from functools import lru_cache
 from typing import Any
 
 from mops.utils.internal_utils import (
-    get_child_elements_with_names,
-    get_all_attributes_from_object,
+    extract_named_objects,
+    extract_all_named_objects,
 )
 
 
@@ -26,11 +26,25 @@ def get_element_info(element: Any, label: str = 'Selector=') -> str:
     return f"{label}'{selector}'" if label else selector
 
 @lru_cache(maxsize=16)
-def get_static(cls: Any):
-    return get_child_elements_with_names(cls).items()
+def get_static_attributes(cls: Any) -> dict:
+    return extract_named_objects(cls)
+
+@lru_cache(maxsize=32)
+def get_all_static_attributes(cls: Any) -> dict:
+    return extract_all_named_objects(cls)
+
+@lru_cache(maxsize=16)
+def get_driver_instance(driver_type, instance) -> bool:
+    return issubclass(driver_type, instance)
+
 
 class InternalMixin:
 
+    driver: None
+
+    def _driver_is_instance(self, instance):
+        return get_driver_instance(type(self.driver), instance)
+
     def _safe_setter(self, var: str, value: Any):
         if not hasattr(self, var):
             setattr(self, var, value)
@@ -41,13 +55,18 @@ class InternalMixin:
 
         :return: None
         """
-        data = {
-            name: value for name, value in get_static(cls)
-            if name not in get_all_attributes_from_object(self).keys()
-        }.items()
+        current_obj_cls = self.__class__
+
+        if current_obj_cls.__dict__.get('_configured'):
+            return
+
+        existing_attrs = set(get_all_static_attributes(current_obj_cls))
+
+        for name, value in get_static_attributes(cls).items():
+            if name not in existing_attrs:
+                setattr(current_obj_cls, name, value)
 
-        for name, item in data:
-            setattr(self.__class__, name, item)
+        current_obj_cls._configured = True
 
     def _repr_builder(self: Any):
         class_name = self.__class__.__name__

{mops-3.3.2 → mops-3.4.0}/mops/mixins/native_context.py

@@ -80,10 +80,9 @@ class NativeSafari:
         if not self.custom_bottom_bar_locator:
             ios_version = float(self.driver_wrapper.driver.caps.get('platformVersion', 18.2))
 
-            if ios_version >= 18.2:
-                self.bottom_bar.locator = self.ios_18_bottom_bar_locator
-            elif ios_version >= 26.0:
+            if ios_version >= 26.0:
                 self.bottom_bar.locator = self.ios_26_bottom_bar_locator
-
+            elif ios_version >= 18.2:
+                self.bottom_bar.locator = self.ios_18_bottom_bar_locator
 
         return self.bottom_bar.size.height

{mops-3.3.2 → mops-3.4.0}/mops/playwright/play_element.py

@@ -7,13 +7,14 @@ from PIL.Image import Image
 from mops.keyboard_keys import KeyboardKeys
 from playwright.sync_api import Error
 from playwright.sync_api import Page as PlaywrightPage
-from playwright.sync_api import Locator, Page, Browser, BrowserContext
+from playwright.sync_api import Locator
 
 from mops.mixins.objects.size import Size
 from mops.mixins.objects.location import Location
 from mops.utils.decorators import retry
 from mops.utils.selector_synchronizer import get_platform_locator, set_playwright_locator
 from mops.abstraction.element_abc import ElementABC
+from mops.exceptions import NotInitializedException
 from mops.exceptions import InvalidSelectorException
 from mops.utils.logs import Logging
 from mops.shared_utils import cut_log_data, get_image
@@ -26,18 +27,10 @@ from mops.utils.internal_utils import (
 
 class PlayElement(ElementABC, Logging, ABC):
 
-    instance: Browser
-    context: BrowserContext
-    driver: Page
     parent: Union[ElementABC, PlayElement]
-    _element: Locator = None
 
-    def __init__(self):  # noqa
-        """
-        Initializing of web element with playwright driver
-        """
-        self.locator = get_platform_locator(self)
-        set_playwright_locator(self)
+    _initialized: bool
+    _element: Locator = None
 
     # Element
 
@@ -50,7 +43,14 @@ class PlayElement(ElementABC, Logging, ABC):
         :param: kwargs: kwargs from Locator object
         :return: Locator
         """
+        if not self._initialized:
+            raise NotInitializedException(
+                f'{repr(self)} object is not initialized. '
+                'Try to initialize base object first or call it directly as a method'
+            )
+
         element = self._element
+
         if not element:
             driver = self._get_base()
             element = driver.locator(self.locator)
@@ -450,3 +450,8 @@ class PlayElement(ElementABC, Logging, ABC):
         :return: first element
         """
         return self.element.first
+
+    def _set_locator(self):
+        self.locator = get_platform_locator(self)
+        set_playwright_locator(self)
+        self._is_locator_configured = True