mops 0.0.1a2__py3-none-any.whl

mops/__init__.py

@@ -0,0 +1,2 @@
+__version__ = '0.0.1a2'
+__project_name__ = 'mops'

mops/exceptions.py

@@ -0,0 +1,133 @@
+from typing import Any
+
+
+class DriverWrapperException(Exception):
+    """
+    Base driver wrapper exceptions
+    """
+
+    def __init__(
+            self,
+            msg: str,
+            actual: Any = None,
+            expected: Any = None,
+            timeout: Any = None,
+            info: Any = None
+    ):
+        self._msg = ''
+        self._original_msg = msg
+        self._timeout = timeout
+        self._actual = actual
+        self._expected = expected
+        self._info = info
+        self.__suppress_context__ = True
+
+    def __str__(self) -> str:
+        return f"\nMessage: {self.msg}"
+
+    @property
+    def msg(self):
+        self._msg = f'{self._original_msg} '
+
+        if self._timeout:
+            self._msg += f'after {self._timeout} seconds. '
+        if self._expected is not None:
+            self._msg += f'Actual: {self.wrap_by_quotes(self._actual)}; ' \
+                         f'Expected: {self.wrap_by_quotes(self._expected)}. '
+        if self._info:
+            self._msg += f'{self._info.get_element_info()}. '
+
+        return self._msg.rstrip()
+
+    def wrap_by_quotes(self, data):
+        if data is None:
+            data = ""
+
+        if isinstance(data, str):
+            return f'"{data}"'
+
+        return data
+
+
+class UnexpectedElementsCountException(DriverWrapperException):
+    """
+    Thrown when elements count isn't equal to expected
+    """
+    pass
+
+
+class UnexpectedElementSizeException(DriverWrapperException):
+    """
+    Thrown when element size isn't equal to expected
+    """
+    pass
+
+
+class UnexpectedValueException(DriverWrapperException):
+    """
+    Thrown when element contains incorrect value
+    """
+    pass
+
+
+class UnexpectedTextException(DriverWrapperException):
+    """
+    Thrown when element contains incorrect text
+    """
+    pass
+
+
+class TimeoutException(DriverWrapperException):
+    """
+    Thrown when timeout exceeded
+    """
+    pass
+
+
+class InvalidSelectorException(DriverWrapperException):
+    """
+    Thrown when element have invalid selector
+    """
+    pass
+
+
+class NoSuchElementException(DriverWrapperException):
+    """
+    Thrown when element could not be found
+    """
+    pass
+
+
+class NoSuchParentException(DriverWrapperException):
+    """
+    Thrown when parent could not be found
+    """
+    pass
+
+
+class ElementNotInteractableException(DriverWrapperException):
+    """
+    Thrown when element found and enabled but not interactable
+    """
+    pass
+
+
+class UnsuitableArgumentsException(DriverWrapperException):
+    """
+    Thrown when object initialised with unsuitable arguments
+    """
+    pass
+
+
+class NotInitializedException(DriverWrapperException):
+    """
+    Thrown when getting access to not initialized object
+    """
+    pass
+
+
+class InvalidLocatorException(DriverWrapperException):
+    """
+    Thrown when locator is invalid
+    """
+    pass

mops/js_scripts.py

@@ -0,0 +1,216 @@
+get_inner_height_js = 'return window.innerHeight'
+get_inner_width_js = 'return window.innerWidth'
+js_click = 'arguments[0].click();'
+
+get_element_position_on_screen_js = """
+function getPositionOnScreen(elem) {
+  let box = elem.getBoundingClientRect();
+  var y;
+  var x;
+  y = Math.round(box.top)
+  x = Math.round(box.left)
+  return {
+    x: x,
+    y: y
+  };
+};
+return getPositionOnScreen(arguments[0])
+"""
+
+get_element_size_js = """
+function getSize(elem) {
+  let box = elem.getBoundingClientRect();
+  var width;
+  var height;
+  width = Math.round(box.width)
+  height = Math.round(box.height)
+  return {
+    width: width,
+    height: height
+  };
+};
+return getSize(arguments[0])
+"""
+
+delete_element_over_js = """
+const elements = document.getElementsByClassName("driver-wrapper-visual-comparison-support-element");
+
+for (var i=0, max=elements.length; i < max; i++) {
+     elements[0].remove()
+};
+"""
+
+add_element_over_js = """
+function appendElement(given_obj) {
+    given_obj = given_obj.getBoundingClientRect();
+    driver_wrapper_obj = document.createElement("div");
+
+    driver_wrapper_obj.style.zIndex=9999999;
+    driver_wrapper_obj.setAttribute("class","driver-wrapper-comparison-support-element");
+
+    driver_wrapper_obj.style.position = "absolute";
+    driver_wrapper_obj.style.backgroundColor = "#000";
+
+    driver_wrapper_obj.style.width = given_obj.width + "px";
+    driver_wrapper_obj.style.height = given_obj.height + "px";
+    driver_wrapper_obj.style.top = (given_obj.top + window.scrollY) + "px";
+    driver_wrapper_obj.style.left = (given_obj.left + window.scrollX) + "px";
+    
+    document.body.appendChild(driver_wrapper_obj);
+};
+
+return appendElement(arguments[0]);
+"""
+
+
+add_driver_index_comment_js = """
+function addComment(driver_index) {
+  comment = document.createComment(" " + driver_index + " ");
+  document.body.appendChild(comment);
+};
+
+addComment(arguments[0])
+"""
+
+find_comments_js = """
+function filterNone() {
+    return NodeFilter.FILTER_ACCEPT;
+}
+
+function getAllComments(rootElem) {
+    var comments = [];
+    // Fourth argument, which is actually obsolete according to the DOM4 standard, is required in IE 11
+    var iterator = document.createNodeIterator(rootElem, NodeFilter.SHOW_COMMENT, filterNone, false);
+    var curNode;
+    while (curNode = iterator.nextNode()) {
+        comments.push(curNode.nodeValue);
+    }
+    return comments;
+}
+
+return getAllComments(document.body);
+"""
+
+trigger_react = """
+function reactTriggerChange(node) {
+  var supportedInputTypes = {
+    color: true,
+    date: true,
+    datetime: true,
+    'datetime-local': true,
+    email: true,
+    month: true,
+    number: true,
+    password: true,
+    range: true,
+    search: true,
+    tel: true,
+    text: true,
+    time: true,
+    url: true,
+    week: true
+  };
+  var nodeName = node.nodeName.toLowerCase();
+  var type = node.type;
+  var event;
+  var descriptor;
+  var initialValue;
+  var initialChecked;
+  var initialCheckedRadio;
+  function deletePropertySafe(elem, prop) {
+    var desc = Object.getOwnPropertyDescriptor(elem, prop);
+    if (desc && desc.configurable) {
+      delete elem[prop];
+    }
+  }
+  function changeRangeValue(range) {
+    var initMin = range.min;
+    var initMax = range.max;
+    var initStep = range.step;
+    var initVal = Number(range.value);
+    range.min = initVal;
+    range.max = initVal + 1;
+    range.step = 1;
+    range.value = initVal + 1;
+    deletePropertySafe(range, 'value');
+    range.min = initMin;
+    range.max = initMax;
+    range.step = initStep;
+    range.value = initVal;
+  }
+  function getCheckedRadio(radio) {
+    var name = radio.name;
+    var radios;
+    var i;
+    if (name) {
+      radios = document.querySelectorAll('input[type="radio"][name="' + name + '"]');
+      for (i = 0; i < radios.length; i += 1) {
+        if (radios[i].checked) {
+          return radios[i] !== radio ? radios[i] : null;
+        }
+      }
+    }
+    return null;
+  }
+  function preventChecking(e) {
+    e.preventDefault();
+    if (!initialChecked) {
+      e.target.checked = false;
+    }
+    if (initialCheckedRadio) {
+      initialCheckedRadio.checked = true;
+    }
+  }
+  if (nodeName === 'select' ||
+    (nodeName === 'input' && type === 'file')) {
+    event = document.createEvent('HTMLEvents');
+    event.initEvent('change', true, false);
+    node.dispatchEvent(event);
+  } else if ((nodeName === 'input' && supportedInputTypes[type]) ||
+    nodeName === 'textarea') {
+    descriptor = Object.getOwnPropertyDescriptor(node, 'value');
+    event = document.createEvent('UIEvents');
+    event.initEvent('focus', false, false);
+    node.dispatchEvent(event);
+    if (type === 'range') {
+      changeRangeValue(node);
+    } else {
+      initialValue = node.value;
+      node.value = initialValue + '#';
+      deletePropertySafe(node, 'value');
+      node.value = initialValue;
+    }
+    event = document.createEvent('HTMLEvents');
+    event.initEvent('propertychange', false, false);
+    event.propertyName = 'value';
+    node.dispatchEvent(event);
+    event = document.createEvent('HTMLEvents');
+    event.initEvent('input', true, false);
+    node.dispatchEvent(event);
+    if (descriptor) {
+      Object.defineProperty(node, 'value', descriptor);
+    }
+  } else if (nodeName === 'input' && type === 'checkbox') {
+    node.checked = !node.checked;
+    event = document.createEvent('MouseEvents');
+    event.initEvent('click', true, true);
+    node.dispatchEvent(event);
+  } else if (nodeName === 'input' && type === 'radio') {
+    initialChecked = node.checked;
+    initialCheckedRadio = getCheckedRadio(node);
+    descriptor = Object.getOwnPropertyDescriptor(node, 'checked');
+    node.checked = !initialChecked;
+    deletePropertySafe(node, 'checked');
+    node.checked = initialChecked;
+    node.addEventListener('click', preventChecking, true);
+    event = document.createEvent('MouseEvents');
+    event.initEvent('click', true, true);
+    node.dispatchEvent(event);
+    node.removeEventListener('click', preventChecking, true);
+    if (descriptor) {
+      Object.defineProperty(node, 'checked', descriptor);
+    }
+  }
+};
+reactTriggerChange(arguments[0]);
+"""

mops/keyboard_keys.py

@@ -0,0 +1,92 @@
+from selenium.webdriver import Keys as SeleniumSourceKeys
+
+from mops.base.driver_wrapper import DriverWrapper
+
+
+class SeleniumKeys(SeleniumSourceKeys):
+    pass
+
+
+class PlaywrightKeys:
+
+    # NULL = '\ue000'
+    # CANCEL = '\ue001'  # ^break
+    # HELP = '\ue002'
+    BACKSPACE = 'Backspace'
+    BACK_SPACE = BACKSPACE
+    TAB = 'Tab'
+    # CLEAR = '\ue005'
+    # RETURN = '\ue006'
+    ENTER = 'Enter'
+    SHIFT = 'Shift'
+    LEFT_SHIFT = SHIFT
+    CONTROL = 'Control'
+    LEFT_CONTROL = CONTROL
+    ALT = 'Alt'
+    LEFT_ALT = ALT
+    # PAUSE = '\ue00b'
+    ESCAPE = 'Escape'
+    # SPACE = '\ue00d'
+    PAGE_UP = 'PageUp'
+    PAGE_DOWN = 'PageDown'
+    END = 'End'
+    HOME = 'Home'
+    LEFT = 'ArrowLeft'
+    ARROW_LEFT = LEFT
+    UP = 'ArrowUp'
+    ARROW_UP = UP
+    RIGHT = 'ArrowRight'
+    ARROW_RIGHT = RIGHT
+    DOWN = 'ArrowDown'
+    ARROW_DOWN = DOWN
+    INSERT = 'Insert'
+    DELETE = 'Delete'
+    # SEMICOLON = '\ue018'
+    EQUALS = 'Equal'
+
+    NUMPAD0 = 'Digit0'  # number pad keys
+    NUMPAD1 = 'Digit1'
+    NUMPAD2 = 'Digit2'
+    NUMPAD3 = 'Digit3'
+    NUMPAD4 = 'Digit4'
+    NUMPAD5 = 'Digit5'
+    NUMPAD6 = 'Digit6'
+    NUMPAD7 = 'Digit7'
+    NUMPAD8 = 'Digit8'
+    NUMPAD9 = 'Digit9'
+    # MULTIPLY = '\ue024'
+    # ADD = '\ue025'
+    # SEPARATOR = '\ue026'
+    # SUBTRACT = '\ue027'
+    # DECIMAL = '\ue028'
+    # DIVIDE = '\ue029'
+
+    F1 = 'F1'
+    F2 = 'F2'
+    F3 = 'F3'
+    F4 = 'F4'
+    F5 = 'F5'
+    F6 = 'F6'
+    F7 = 'F7'
+    F8 = 'F8'
+    F9 = 'F9'
+    F10 = 'F10'
+    F11 = 'F11'
+    F12 = 'F12'
+
+    META = 'Meta'
+    # COMMAND = '\ue03d'
+    # ZENKAKU_HANKAKU = '\ue040'
+
+
+class Interceptor(type):
+
+    def __getattribute__(self, item):
+        if DriverWrapper.is_selenium:
+            return getattr(SeleniumKeys, item)
+        else:
+            return getattr(PlaywrightKeys, item, NotImplementedError(f'Key is not added to Mops framework'))
+
+
+class KeyboardKeys(SeleniumKeys, PlaywrightKeys, metaclass=Interceptor):
+    pass

mops/shared_utils.py

@@ -0,0 +1,102 @@
+import io
+import logging
+from subprocess import Popen, PIPE, run
+
+from PIL import Image
+
+
+def _scaled_screenshot(screenshot_binary: bytes, width: int) -> Image:
+    """
+    Get scaled screenshot to fit driver window / element size
+
+    :param screenshot_binary: original screenshot binary
+    :param width: driver or element width
+    :return: scaled image binary
+    """
+    img_binary = get_image(screenshot_binary)
+    scale = img_binary.size[0] / width
+
+    if scale != 1:
+        new_image_size = (int(img_binary.size[0] / scale), int(img_binary.size[1] / scale))
+        img_binary = img_binary.resize(new_image_size, Image.Resampling.LANCZOS)
+
+    return img_binary
+
+
+def get_image(screenshot_binary: bytes):
+    return Image.open(io.BytesIO(screenshot_binary))
+
+
+def rescale_image(screenshot_binary: bytes, scale=3, img_format='JPEG') -> bytes:
+    img = get_image(screenshot_binary)
+    img = img.resize((img.width // scale, img.height // scale), Image.Resampling.LANCZOS)
+
+    return save_image(img, img_format)
+
+
+def resize_image(image1: str, image2: str, img_format='JPEG') -> bytes:
+    img1 = Image.open(image1)
+    img2 = Image.open(image2)
+
+    width, height = img2.size
+    img1.resize((width, height), Image.Resampling.LANCZOS)
+
+    return save_image(img1, img_format)
+
+
+def save_image(img: Image, img_format='JPEG'):
+    result_img_binary = io.BytesIO()
+    img.convert('RGB').save(result_img_binary, format=img_format, optimize=True)
+    return result_img_binary.getvalue()
+
+
+def shell_running_command(cmd, **kwargs):
+    return Popen(cmd, shell=True, stdout=PIPE, stderr=PIPE, close_fds=True, **kwargs)
+
+
+def shell_command(cmd,  **kwargs):
+    process = run(cmd, shell=True, **kwargs)
+
+    if process.stdout:
+        process.output = process.stdout.decode('utf8').replace('\n', '')
+    if process.stderr:
+        process.errors = process.stderr.decode('utf8').replace('\n', '')
+    if isinstance(process.returncode, int):
+        process.is_success = process.returncode == 0
+
+    return process
+
+
+def cut_log_data(data: str, length=50) -> str:
+    """
+    Cut given data for reducing log length
+
+    :param data: original data ~ 'very long string for typing. string endless continues'
+    :param length: length to cut given data ~ 20
+    :return: edited data ~ 'Type text: "very long string for >>> 36 characters"'
+    """
+    data = str(data)
+    return f'{data[:length]} >>> {len(data[length:])} characters' if len(data) > length else data
+
+
+def disable_logging(loggers: list) -> None:
+    """
+    Disable logging for given loggers
+
+    :param loggers: list of loggers to be disabled
+    :return: None
+    """
+    for logger in loggers:
+        logging.getLogger(logger).disabled = True
+
+
+def set_log_level(loggers: list, level: int) -> None:
+    """
+    Set log level for given loggers
+
+    :param loggers: list of loggers to be disabled
+    :param level: level to be set
+    :return: None
+    """
+    for logger in loggers:
+        logging.getLogger(logger).setLevel(level)

mops/visual_comparison.py

@@ -0,0 +1,461 @@
+from __future__ import annotations
+
+import os
+import re
+import shutil
+import time
+import math
+import json
+import base64
+import importlib
+from urllib.parse import urljoin
+from typing import Union, List, Any, Tuple, Optional
+from string import punctuation
+
+try:
+    import cv2.cv2 as cv2  # ~cv2@4.5.5.62 + python@3.8/9/10
+except ImportError:
+    import cv2  # ~cv2@4.10.0.84 + python@3.11/12
+import numpy
+from skimage._shared.utils import check_shape_equality  # noqa
+from skimage.metrics import structural_similarity
+from PIL import Image
+
+from mops.exceptions import DriverWrapperException, TimeoutException
+from mops.js_scripts import add_element_over_js, delete_element_over_js
+from mops.mixins.objects.cut_box import CutBox
+from mops.utils.logs import autolog
+from mops.mixins.internal_mixin import get_element_info
+
+
+class VisualComparison:
+
+    visual_regression_path = ''
+    test_item = None
+    attach_diff_image_path = False
+    skip_screenshot_comparison = False
+    visual_reference_generation = False
+    hard_visual_reference_generation = False
+    soft_visual_reference_generation = False
+    default_delay = 0.75
+    default_threshold = 0
+    dynamic_threshold_factor = 0
+    diff_color_scheme = (0, 255, 0)
+
+    __initialized = False
+
+    def __init__(self, driver_wrapper, element=None):
+        self.driver_wrapper = driver_wrapper
+        self.element_wrapper = element
+        self.screenshot_name = 'default'
+
+        if self.dynamic_threshold_factor and self.default_threshold:
+            raise Exception('Provide only one argument for threshold of visual comparison')
+
+        if not self.__initialized:
+            self.__init_session()
+
+    def __init_session(self):
+        root_path = self.visual_regression_path
+
+        if not root_path:
+            raise Exception('Provide visual regression path to environment. '
+                            f'Example: {self.__class__.__name__}.visual_regression_path = "src"')
+
+        root_path = root_path if root_path.endswith('/') else f'{root_path}/'
+        self.reference_directory = f'{root_path}reference/'
+        self.output_directory = f'{root_path}output/'
+        self.diff_directory = f'{root_path}difference/'
+
+        os.makedirs(os.path.dirname(self.reference_directory), exist_ok=True)
+        os.makedirs(os.path.dirname(self.output_directory), exist_ok=True)
+        os.makedirs(os.path.dirname(self.diff_directory), exist_ok=True)
+
+        self.__initialized = True
+
+    def _save_screenshot(
+            self,
+            screenshot_name: str,
+            delay: Union[int, float],
+            remove: list,
+            fill_background: bool,
+            cut_box: Optional[CutBox],
+    ):
+        time.sleep(delay)
+
+        self._fill_background(fill_background)
+        self._appends_dummy_elements(remove)
+
+        if fill_background or remove:
+            time.sleep(0.1)
+
+        desired_obj = self.element_wrapper or self.driver_wrapper.anchor or self.driver_wrapper
+        image = desired_obj.screenshot_image()
+
+        if cut_box:
+            image = image.crop(cut_box.get_box(image.size))
+
+        desired_obj.save_screenshot(screenshot_name, screenshot_base=image)
+
+        self._remove_dummy_elements()
+
+    def assert_screenshot(
+            self,
+            filename: str,
+            test_name: str,
+            name_suffix: str,
+            threshold: Union[int, float],
+            delay: Union[int, float],
+            scroll: bool,
+            remove: List[Any],
+            fill_background: Union[str, bool],
+            cut_box: Optional[CutBox]
+    ) -> VisualComparison:
+        """
+        Assert given (by name) and taken screenshot equals
+
+        :param filename: full screenshot name. Custom filename will be used if empty string given
+        :param test_name: test name for custom filename. Will try to find it automatically if empty string given
+        :param name_suffix: filename suffix. Good to use for same element with positive/negative case
+        :param threshold: possible threshold
+        :param delay: delay before taking screenshot
+        :param scroll: scroll to element before taking the screenshot
+        :param remove: remove elements from screenshot
+        :param fill_background: fill background with given color or black color by default
+        :param cut_box: custom coordinates, that will be cut from original image (left, top, right, bottom)
+        :return: self
+        """
+        if self.skip_screenshot_comparison:
+            return self
+
+        remove = remove if remove else []
+        screenshot_params = dict(delay=delay, remove=remove, fill_background=fill_background, cut_box=cut_box)
+
+        if filename:
+            if name_suffix:
+                filename = f'{filename}_{name_suffix}'
+            self.screenshot_name = filename
+        else:
+            self.screenshot_name = self._get_screenshot_name(test_name, name_suffix)
+
+        reference_file = f'{self.reference_directory}{self.screenshot_name}.png'
+        output_file = f'{self.output_directory}{self.screenshot_name}.png'
+        diff_file = f'{self.diff_directory}diff_{self.screenshot_name}.png'
+
+        if scroll:
+            self.element_wrapper.scroll_into_view()
+
+        if self.hard_visual_reference_generation:
+            self._save_screenshot(reference_file, **screenshot_params)
+            return self
+
+        image = cv2.imread(reference_file)
+        if isinstance(image, type(None)):
+            self._save_screenshot(reference_file, **screenshot_params)
+
+            if self.visual_reference_generation or self.soft_visual_reference_generation:
+                return self
+
+            self._disable_reruns()
+
+            self._attach_allure_diff(reference_file, reference_file, reference_file)
+            raise AssertionError(f'Reference file "{reference_file}" not found, but its just saved. '
+                                 f'If it CI run, then you need to commit reference files.')
+
+        if self.visual_reference_generation and not self.soft_visual_reference_generation:
+            return self
+
+        self._save_screenshot(output_file, **screenshot_params)
+
+        try:
+            self._assert_same_images(output_file, reference_file, diff_file, threshold)
+            for file_path in (output_file, diff_file):
+                if os.path.exists(file_path):
+                    os.remove(file_path)
+        except AssertionError as exc:
+            if self.soft_visual_reference_generation:
+                if os.path.exists(reference_file):
+                    os.remove(reference_file)
+                shutil.move(output_file, reference_file)
+            else:
+                raise exc
+
+        return self
+
+    @staticmethod
+    def calculate_threshold(file: str, dynamic_threshold_factor: int = None) -> Tuple:
+        """
+        Calculate possible threshold, based on dynamic_threshold_factor
+
+        :param file: image file path for calculation
+        :param dynamic_threshold_factor: use provided threshold factor
+        :return: tuple of calculated threshold and additional data
+        """
+        factor = VisualComparison.dynamic_threshold_factor or dynamic_threshold_factor
+        img = Image.open(file)
+        width, height = img.size
+        pixels_grid = height * width
+        calculated_threshold = factor / math.sqrt(pixels_grid)
+        pixels_allowed = int(pixels_grid / 100 * calculated_threshold)
+        return calculated_threshold, \
+            f'\nAdditional info: {width}x{height}; {calculated_threshold=}; {pixels_allowed=} from {pixels_grid}'
+
+    def _appends_dummy_elements(self, remove_data: list) -> VisualComparison:
+        """
+        Placed an element above each from given list and paints it black
+
+        :param remove_data: list of elements to be fake removed
+        :return: VisualComparison
+        """
+        for obj in remove_data:
+
+            try:
+                obj.wait_visibility(silent=True)
+            except TimeoutException:
+                msg = f'Cannot find {obj.name} while removing background from screenshot. {get_element_info(obj)}'
+                raise TimeoutException(msg)
+
+            obj.execute_script(add_element_over_js)
+        return self
+
+    def _remove_dummy_elements(self) -> VisualComparison:
+        """
+        Remove all dummy elements from DOM
+
+        :return: VisualComparison
+        """
+        self.driver_wrapper.execute_script(delete_element_over_js)
+        return self
+
+    def _fill_background(self, fill_background_data: Union[bool, str]) -> VisualComparison:
+        """
+        Fill background of element
+
+        :param fill_background_data: fill background with given color or black color by default
+        :return: VisualComparison
+        """
+        if not fill_background_data:
+            return self
+
+        element_wrapper = self.element_wrapper
+
+        color = fill_background_data if type(fill_background_data) is str else 'black'
+        element_wrapper\
+            .wait_visibility(silent=True)\
+            .execute_script(f'arguments[0].style.background = "{color}";')
+
+        return self
+
+    def _assert_same_images(self, actual_file: str, reference_file: str, diff_file: str,
+                            threshold: Union[int, float]) -> VisualComparison:
+        """
+        Assert that given images are equal to each other
+
+        :param actual_file: actual image path
+        :param reference_file: reference image path
+        :param diff_file: difference image name
+        :param threshold: possible difference in percents
+        :return: VisualComparison
+        """
+        reference_image = cv2.imread(reference_file)
+        output_image = cv2.imread(actual_file)
+        threshold = threshold if threshold is not None else self.default_threshold
+
+        additional_data = ''
+        if not threshold:
+            threshold, additional_data = self.calculate_threshold(reference_file)
+
+        try:
+            check_shape_equality(reference_image, output_image)
+        except ValueError:
+            self._attach_allure_diff(actual_file, reference_file, actual_file)
+            # todo: watermark / fill size difference with color on diff image is better, but need more time
+            # rescale output image to the size of reference image, and save it as diff image
+            height, width, _ = reference_image.shape
+            scaled_image = cv2.resize(output_image, (width, height))
+            cv2.imwrite(diff_file, scaled_image)
+            raise AssertionError(f"↓\nImage size (width, height) is not same for '{self.screenshot_name}':"
+                                 f"\nExpected: {reference_image.shape[0:2]};"
+                                 f"\nActual: {output_image.shape[0:2]}.")
+
+        diff, actual_threshold = self._get_difference(reference_image, output_image, threshold)
+        is_different = actual_threshold > threshold
+
+        if is_different:
+            cv2.imwrite(diff_file, diff)
+            self._attach_allure_diff(actual_file, reference_file, diff_file)
+
+        diff_data = ""
+        if self.attach_diff_image_path:
+            diff_data = f"\nDiff image {urljoin('file:', diff_file)}"
+
+        base_error = f"↓\nVisual mismatch found for '{self.screenshot_name}'{diff_data}"
+
+        if is_different:
+            raise AssertionError(f"{base_error}:"
+                                 f"\nThreshold is: {actual_threshold};"
+                                 f"\nPossible threshold is: {threshold}"
+                                 + additional_data)
+
+        return self
+
+    def _get_screenshot_name(self, test_function_name: str = '', name_suffix: str = '') -> str:
+        """
+        Get screenshot name
+
+        :param test_function_name: execution test name. Will try to find it automatically if empty string given
+        :return: custom screenshot filename:
+          :::
+          - playwright: test_screenshot_rubiks_cube_playwright_chromium
+          - selenium: test_screenshot_rubiks_cube_mac_os_x_selenium_chrome
+          - appium ios: test_screenshot_rubiks_cube_iphone_13_v_15_4_appium_safari
+          - appium android: test_screenshot_rubiks_cube_pixel5_v_12_appium_chrome
+          :::
+        """
+        test_function_name = test_function_name if test_function_name else getattr(self.test_item, 'name', '')
+        if not test_function_name:
+            raise Exception('Draft: provide test item self.test_item')
+
+        test_function_name = test_function_name.replace('[', '_')  # required here for better separation
+
+        if self.driver_wrapper.is_android or self.driver_wrapper.is_ios:
+            caps = self.driver_wrapper.driver.caps
+            device_name = caps.get('customDeviceName', '')
+
+            if self.driver_wrapper.is_android and not device_name:
+                device_name = caps.get('avd', f'{caps.get("deviceManufacturer")}_{caps.get("deviceModel", "none")}')
+            elif self.driver_wrapper.is_ios and not device_name:
+                device_name = caps['deviceName']
+
+            platform_version = caps['platformVersion']
+            screenshot_name = f'{device_name}_v_{platform_version}_appium_{self.driver_wrapper.browser_name}'
+        elif self.driver_wrapper.is_selenium:
+            platform_name = self.driver_wrapper.driver.caps["platformName"]
+            screenshot_name = f'{platform_name}_selenium_{self.driver_wrapper.browser_name}'
+        elif self.driver_wrapper.is_playwright:
+            screenshot_name = f'playwright_{self.driver_wrapper.browser_name}'
+        else:
+            raise DriverWrapperException('Cant find current platform')
+
+        name_suffix = f'_{name_suffix}_' if name_suffix else '_'
+        location_name = self.element_wrapper.name if self.element_wrapper else 'entire_screen'
+        base_name = f'{test_function_name}{location_name}{name_suffix}'
+        if 'mobile' not in base_name and self.driver_wrapper.is_mobile_resolution:
+            location_name += '_mobile_'
+        screenshot_name = f'{test_function_name}_{location_name}{name_suffix}{screenshot_name}'
+
+        for item in (']', '"', "'"):
+            screenshot_name = screenshot_name.replace(item, '')
+
+        for item in punctuation + ' ':
+            screenshot_name = screenshot_name.replace(item, '_')
+
+        return self._remove_unexpected_underscores(screenshot_name).lower()
+
+    def _get_difference(
+            self,
+            reference_img: numpy.ndarray,
+            actual_img: numpy.ndarray,
+            possible_threshold: Union[int, float]
+    ) -> tuple[numpy.ndarray, float]:
+        """
+        Calculate difference between two images
+
+        :param reference_img: image 1, numpy.ndarray
+        :param actual_img: image 2, numpy.ndarray
+        :return: (diff image, diff float value )
+        """
+        # Convert images to grayscale
+        reference_img_gray = cv2.cvtColor(reference_img, cv2.COLOR_BGR2GRAY)
+        actual_img_gray = cv2.cvtColor(actual_img, cv2.COLOR_BGR2GRAY)
+
+        # Compute SSIM between the two images
+        score, diff = structural_similarity(reference_img_gray, actual_img_gray, full=True)
+        score *= 100
+
+        # The diff image contains the actual image differences between the two images
+        # and is represented as a floating point data type in the range [0,1]
+        # so we must convert the array to 8-bit unsigned integers in the range
+        # [0,255] before we can use it with OpenCV
+        diff = (diff * 255).astype("uint8")
+        diff_box = cv2.merge([diff, diff, diff])
+
+        # Threshold the difference image, followed by finding contours to
+        # obtain the regions of the two input images that differ
+        thresh = cv2.threshold(diff, 0, 255, cv2.THRESH_BINARY_INV | cv2.THRESH_OTSU)[1]
+        contours = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        contours = contours[0] if len(contours) == 2 else contours[1]
+
+        mask = numpy.zeros(reference_img.shape, dtype='uint8')
+        filled_after = actual_img.copy()
+        percent_diff = 100 - score
+        is_different_enough = percent_diff > possible_threshold
+
+        for c in contours:
+            if is_different_enough or cv2.contourArea(c) > 40:
+                x, y, w, h = cv2.boundingRect(c)
+                cv2.rectangle(reference_img, (x, y), (x + w, y + h), self.diff_color_scheme, 2)
+                cv2.rectangle(actual_img, (x, y), (x + w, y + h), self.diff_color_scheme, 2)
+                cv2.rectangle(diff_box, (x, y), (x + w, y + h), self.diff_color_scheme, 2)
+                cv2.drawContours(mask, [c], 0, (255, 255, 255), -1)
+                cv2.drawContours(filled_after, [c], 0, self.diff_color_scheme, -1)
+
+        diff_image, percent_diff = filled_after, 100 - score
+        return diff_image, percent_diff
+
+    def _attach_allure_diff(self, actual_path: str, expected_path: str, diff_path: str = None) -> None:
+        """
+        Attach screenshots to allure screen diff plugin
+        https://github.com/allure-framework/allure2/blob/master/plugins/screen-diff-plugin/README.md
+
+        :param actual_path: path of actual image
+        :param expected_path: path of expected image
+        :param diff_path: path of diff image
+        :return: None
+        """
+        allure = None
+
+        try:
+            allure = importlib.import_module('allure')
+        except ModuleNotFoundError:
+            autolog('Skip screenshot attaching due to allure module not found')
+
+        if allure:
+            data = [('actual', actual_path), ('expected', expected_path)]
+            diff_dict = {}
+
+            if diff_path:
+                data.append(('diff', diff_path))
+
+            for name, path in data:
+                with open(path, 'rb') as image:
+                    diff_dict.update({name: f'data:image/png;base64,{base64.b64encode(image.read()).decode("ascii")}'})
+
+            allure.attach(
+                name=f'diff_for_{self.screenshot_name}',
+                body=json.dumps(diff_dict),
+                attachment_type='application/vnd.allure.image.diff'
+            )
+
+    def _disable_reruns(self) -> None:
+        """
+        Disable reruns for pytest
+
+        :return: None
+        """
+        try:
+            pytest_rerun = importlib.import_module('pytest_rerunfailures')
+        except ModuleNotFoundError:
+            return None
+
+        if hasattr(self.test_item, 'execution_count'):
+            self.test_item.execution_count = pytest_rerun.get_reruns_count(self.test_item) + 1
+
+    @staticmethod
+    def _remove_unexpected_underscores(text) -> str:
+        """
+        Remove multiple underscores from given text
+
+        :return: test_screenshot__data___name -> test_screenshot_data_name
+        """
+        return re.sub(r'_{2,}', '_', text)

mops-0.0.1a2.dist-info/METADATA

@@ -0,0 +1,96 @@
+Metadata-Version: 2.1
+Name: mops
+Version: 0.0.1a2
+Summary: Wrapper of Selenium, Appium and Playwright with single API
+Author-email: Podolian Vladimir <vladimir.podolyan64@gmail.com>
+License: MIT
+Project-URL: Changelog, https://github.com/CustomEnv/mops/blob/master/CHANGELOG.md
+Project-URL: Documentation, https://mops.readthedocs.io
+Project-URL: Homepage, https://github.com/CustomEnv/mops
+Project-URL: Source, https://github.com/CustomEnv/mops
+Project-URL: Tracker, https://github.com/CustomEnv/mops/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Testing :: Acceptance
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: Appium-Python-Client >=3.1.0
+Requires-Dist: playwright >=1.41.0
+Requires-Dist: selenium >=4.12.0
+Requires-Dist: numpy >=2.0.1 ; python_version >= "3.11"
+Requires-Dist: opencv-python >=4.10.0.84 ; python_version >= "3.11"
+Requires-Dist: scikit-image >=0.24.0 ; python_version >= "3.11"
+Requires-Dist: Pillow >=10.4.0 ; python_version >= "3.12"
+Requires-Dist: numpy <2.0.0,>=1.24.2 ; python_version >= "3.8" and python_version <= "3.10"
+Requires-Dist: opencv-python <4.10.0.84,>=4.5.5.64 ; python_version >= "3.8" and python_version <= "3.10"
+Requires-Dist: scikit-image <0.24.0,>=0.20.0 ; python_version >= "3.8" and python_version <= "3.10"
+Requires-Dist: Pillow <10.4.0,>=9.4.0 ; python_version >= "3.8" and python_version <= "3.11"
+
+<p align="center">
+  <a href="https://mops.readthedocs.io"><img src="docs/source/_static/preview.png"></a>
+</p>
+
+<h2 align="center">Automation Beyond Limits</h2>
+
+<p align="center">
+    <a href="https://github.com/CustomEnv/mops/blob/master/LICENSE"><img alt="GitHub License" src="https://img.shields.io/github/license/CustomEnv/mops?logo=github&color=%234F2684&labelColor=%232E353B"></a>
+    <a href="https://pypi.org/project/mops/"><img alt="PyPI - Python Version" src="https://img.shields.io/pypi/pyversions/mops?logo=pypi&labelColor=%232E353B"></a>
+    <a href="https://pypi.org/project/mops/"><img alt="PyPI - Version" src="https://img.shields.io/pypi/v/mops?logo=pypi&labelColor=%232E353B"></a>
+</p> 
+
+<p align="center">
+    <a href="https://mops.readthedocs.io"><img alt="Documentation Status" src="https://img.shields.io/readthedocs/mops?logo=readthedocs&labelColor=%232E353B&label=docs"></a>
+    <a href="https://github.com/CustomEnv/mops/actions/workflows/static_tests.yml"><img alt="GitHub Actions Workflow Status" src="https://img.shields.io/github/actions/workflow/status/CustomEnv/mops/static_tests.yml?logo=github&label=Unit%20Tests&labelColor=%232E353B"></a>
+    <a href="https://github.com/CustomEnv/mops/actions/workflows/playwright_tests.yml"><img alt="GitHub Actions Workflow Status" src="https://img.shields.io/github/actions/workflow/status/CustomEnv/mops/playwright_tests.yml?logo=github&label=Playwright%20Tests&labelColor=%232E353B"></a>
+</p> 
+
+<p align="center">
+    <a href="https://github.com/CustomEnv/mops/actions/workflows/selenium_tests.yml"><img alt="GitHub Actions Workflow Status" src="https://img.shields.io/github/actions/workflow/status/CustomEnv/mops/selenium_tests.yml?logo=github&label=Selenium%20Tests&labelColor=%232E353B"></a>
+    <a href="https://github.com/CustomEnv/mops/actions/workflows/selenium_safari_tests.yml"><img alt="GitHub Actions Workflow Status" src="https://img.shields.io/github/actions/workflow/status/CustomEnv/mops/selenium_safari_tests.yml?logo=github&label=Selenium%20Safari%20Tests&labelColor=%232E353B"></a>
+    <a href="https://github.com/CustomEnv/mops/actions/workflows/appium_android_tests.yml"><img alt="GitHub Actions Workflow Status" src="https://img.shields.io/github/actions/workflow/status/CustomEnv/mops/appium_android_tests.yml?logo=github&label=Android%20Tests&labelColor=%232E353B"></a>
+    <a href="https://github.com/CustomEnv/mops/actions/workflows/appium_ios_tests.yml"><img alt="GitHub Actions Workflow Status" src="https://img.shields.io/github/actions/workflow/status/CustomEnv/mops/appium_ios_tests.yml?logo=github&label=iOS%20Tests&labelColor=%232E353B"></a>
+</p>
+
+
+Mops is a Python framework that seamlessly wraps over Selenium, Appium, and sync Playwright,
+providing a unified interface for browser and mobile automation. With Mops, you can effortlessly switch 
+between these engines within the same test, allowing you to leverage the unique features of each framework without boundaries.
+
+Whether you're running tests on web browsers, mobile devices, or a combination of both, Mops simplifies the 
+process, giving you the flexibility and power to automate complex testing scenarios with ease.
+
+## Key Features
+
+- **Seamless Integration**: Mops integrates with Selenium, Appium, and Playwright, allowing you to use the best-suited engine for your specific testing needs.
+- **Unified API**: A single, easy-to-use API that abstracts away the differences between Selenium, Appium, and Playwright, making your test scripts more readable and maintainable.
+- **Engine Switching**: Switch between Selenium, Appium, and Playwright within the same test case, enabling cross-platform and cross-browser testing with minimal effort.
+- **Visual Regression Testing**: Perform visual regression tests using the integrated visual regression tool, available across all supported frameworks. This ensures your UI remains consistent across different browsers and devices.
+- **Advanced Features**: Leverage the advanced features of each framework, such as Playwright's mocks and Appium's real mobile devices support, all while using the same testing framework.
+- **Extensibility**: Extend the framework with custom functionality tailored to your project's specific requirements.
+- **Automatic Locator Type Definition**: The locator type will be automatically determined based on the provided locator string or `Locator` object.
+
+
+## Installation and usage
+For information on installation and usage, please refer to our **[ReadTheDocs documentation](https://mops.readthedocs.io)**. Check it out for more details.
+
+
+## Contributing
+
+Mops is an open-source project, and we welcome contributions from the community. If you'd like to contribute, please open an pull request from your fork
+
+## License
+
+Mops is licensed under the Apache License. See the [LICENSE](https://github.com/CustomEnv/mops/blob/master/LICENSE) file for more details.
+
+## Support
+
+If you encounter any issues or have questions, please feel free to reach out via our [GitHub Issues](https://github.com/CustomEnv/mops/issues) page.
+
+Thank you for choosing Mops for your automation needs!

mops-0.0.1a2.dist-info/RECORD

@@ -0,0 +1,10 @@
+mops/__init__.py,sha256=O8PeeqHUMoZdz4VsQRUNib2bQAcvWGIWuzPTkKRbdww,50
+mops/exceptions.py,sha256=sKNSi2oMZTAMCE5enmuHoLomF7FIJoyXzmKRfXZ8PnU,2841
+mops/js_scripts.py,sha256=rJ-L91X_y_-A7kONazE5LM7uR-KuVrBZL6LhkjHOsao,6118
+mops/keyboard_keys.py,sha256=0LT-O0bdpOh_Lcn64hWD45201G7x2n-CJ1bPiTuBi5g,1960
+mops/shared_utils.py,sha256=a7BWbHqj7EFRuvMXhRlwUhxqNZQ3sGWtbHcDmeA8J5Q,2999
+mops/visual_comparison.py,sha256=YwOYKAD_5nBy6b7mjLHwIXTYzCkzdd0BfuayQWDTREk,18703
+mops-0.0.1a2.dist-info/METADATA,sha256=sVf0KnKHtlXxiDIwcTY_zZg2zmoMyFhvvknU1PM8fxw,6999
+mops-0.0.1a2.dist-info/WHEEL,sha256=P9jw-gEje8ByB7_hXoICnHtVCrEwMQh-630tKvQWehc,91
+mops-0.0.1a2.dist-info/top_level.txt,sha256=OJY8xq2xmWlDOn4RvZo6EvDQGV3d4dN4SyPVkcpM8A8,5
+mops-0.0.1a2.dist-info/RECORD,,

mops-0.0.1a2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mops-0.0.1a2.dist-info/top_level.txt

@@ -0,0 +1 @@
+mops