robotframework-appiumwindows 0.1.0__py3-none-any.whl

AppiumLibrary/keywords/keywordgroup.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+import inspect
+import functools
+
+# Internal/private marker attribute names
+_RUN_ON_FAILURE_ATTR = "__rof_wrapped__"
+_IGNORE_RUN_FAILURE_ATTR = "__rof_ignore__"
+_ORIGINAL_METHOD_ATTR = "__original__"
+
+
+def _run_on_failure_decorator(method):
+    """Decorator to wrap keyword methods with _run_on_failure support."""
+    if getattr(method, _RUN_ON_FAILURE_ATTR, False):
+        # Already decorated → skip re-wrapping
+        return method
+
+    @functools.wraps(method)
+    def wrapper(*args, **kwargs):
+        try:
+            return method(*args, **kwargs)
+        except Exception:
+            self = args[0] if args else None
+            if self and hasattr(self, "_run_on_failure"):
+                self._run_on_failure()
+            raise
+
+    setattr(wrapper, _RUN_ON_FAILURE_ATTR, True)      # mark as decorated
+    setattr(wrapper, _ORIGINAL_METHOD_ATTR, method)   # keep reference to original
+    return wrapper
+
+
+def ignore_on_fail(method):
+    """Decorator to mark methods that should never be wrapped by run_on_failure."""
+    setattr(method, _IGNORE_RUN_FAILURE_ATTR, True)
+    return method
+
+
+class KeywordGroupMetaClass(type):
+    def __new__(cls, clsname, bases, attrs):
+        for name, method in list(attrs.items()):
+            if (
+                not name.startswith('_')
+                and inspect.isfunction(method)
+                and not getattr(method, _IGNORE_RUN_FAILURE_ATTR, False)
+                and not getattr(method, _RUN_ON_FAILURE_ATTR, False)
+            ):
+                attrs[name] = _run_on_failure_decorator(method)
+        return super().__new__(cls, clsname, bases, attrs)
+
+
+class KeywordGroup(metaclass=KeywordGroupMetaClass):
+
+    def _invoke_original(self, method, *args, **kwargs):
+        """
+        Call the original (undecorated) implementation of a method.
+
+        Accepts either:
+          - method name (str), e.g. self._invoke_original("click", el)
+          - bound method itself, e.g. self._invoke_original(self.click, el)
+
+        Falls back to the current method if undecorated.
+        Returns None if method not found at all.
+        """
+        if isinstance(method, str):
+            method = getattr(self, method, None)
+        if method is None:
+            return None
+
+        original = getattr(method, _ORIGINAL_METHOD_ATTR, method)
+        return original(self, *args, **kwargs)

AppiumLibrary/locators/__init__.py

@@ -0,0 +1,7 @@
+# -*- coding: utf-8 -*-
+
+from .elementfinder import ElementFinder
+
+__all__ = [
+    "ElementFinder",
+]

AppiumLibrary/locators/elementfinder.py

@@ -0,0 +1,264 @@
+# -*- coding: utf-8 -*-
+
+from AppiumLibrary import utils
+from appium.webdriver.common.appiumby import AppiumBy
+from robot.api import logger
+
+
+class ElementFinder(object):
+
+    def __init__(self):
+        self._strategies = {
+            'identifier': self._find_by_identifier,
+            'id': self._find_by_id,
+            'name': self._find_by_name,
+            'xpath': self._find_by_xpath,
+            'class': self._find_by_class_name,
+            'accessibility_id': self._find_element_by_accessibility_id,
+            'android': self._find_by_android,
+            'viewtag': self._find_by_android_viewtag,
+            'data_matcher': self._find_by_android_data_matcher,
+            'view_matcher': self._find_by_android_view_matcher,
+            'ios': self._find_by_ios,
+            'css': self._find_by_css_selector,
+            'jquery': self._find_by_sizzle_selector,
+            'predicate': self._find_by_ios_predicate,
+            'chain': self._find_by_chain,
+            'default': self._find_by_default
+        }
+
+    def find(self, application, locator, tag=None):
+        assert application is not None
+        assert locator is not None and len(locator) > 0
+
+        (prefix, criteria) = self._parse_locator(locator)
+        prefix = 'default' if prefix is None else prefix
+        strategy = self._strategies.get(prefix)
+        if strategy is None:
+            raise ValueError("Element locator with prefix '" + prefix + "' is not supported")
+        (tag, constraints) = self._get_tag_and_constraints(tag)
+        return strategy(application, criteria, tag, constraints)
+
+    # Strategy routines, private
+
+    def _find_by_identifier(self, application, criteria, tag, constraints):
+        elements = self._normalize_result(application.find_elements(by=AppiumBy.ID, value=criteria))
+        elements.extend(self._normalize_result(application.find_elements(by=AppiumBy.NAME, value=criteria)))
+        return self._filter_elements(elements, tag, constraints)
+
+    def _find_by_id(self, application, criteria, tag, constraints):
+        # print(f"criteria is {criteria}")
+        return self._filter_elements(
+            application.find_elements(by=AppiumBy.ID, value=criteria),
+            tag, constraints)
+
+    def _find_by_name(self, application, criteria, tag, constraints):
+        return self._filter_elements(
+            application.find_elements(by=AppiumBy.NAME, value=criteria),
+            tag, constraints)
+
+    def _find_by_xpath(self, application, criteria, tag, constraints):
+        return self._filter_elements(
+            application.find_elements(by=AppiumBy.XPATH, value=criteria),
+            tag, constraints)
+
+    def _find_by_dom(self, application, criteria, tag, constraints):
+        result = application.execute_script("return %s;" % criteria)
+        if result is None:
+            return []
+        if not isinstance(result, list):
+            result = [result]
+        return self._filter_elements(result, tag, constraints)
+
+    def _find_by_sizzle_selector(self, application, criteria, tag, constraints):
+        js = "return jQuery('%s').get();" % criteria.replace("'", "\\'")
+        return self._filter_elements(
+            application.execute_script(js),
+            tag, constraints)
+
+    def _find_by_link_text(self, application, criteria, tag, constraints):
+        return self._filter_elements(
+            application.find_elements(by=AppiumBy.LINK_TEXT, value=criteria),
+            tag, constraints)
+
+    def _find_by_css_selector(self, application, criteria, tag, constraints):
+        return self._filter_elements(
+            application.find_elements(by=AppiumBy.CSS_SELECTOR, value=criteria),
+            tag, constraints)
+
+    def _find_by_tag_name(self, application, criteria, tag, constraints):
+        return self._filter_elements(
+            application.find_elements(by=AppiumBy.TAG_NAME, value=criteria),
+            tag, constraints)
+
+    def _find_by_class_name(self, application, criteria, tag, constraints):
+        return self._filter_elements(
+            application.find_elements(by=AppiumBy.CLASS_NAME, value=criteria),
+            tag, constraints)
+
+    def _find_element_by_accessibility_id(self, application, criteria, tag, constraints):
+        return self._filter_elements(
+            application.find_elements(by=AppiumBy.ACCESSIBILITY_ID, value=criteria),
+            tag, constraints)
+
+    def _find_by_android(self, application, criteria, tag, constraints):
+        """Find element matches by UI Automator."""
+        return self._filter_elements(
+            application.find_elements(by=AppiumBy.ANDROID_UIAUTOMATOR, value=criteria),
+            tag, constraints)
+
+    def _find_by_android_viewtag(self, application, criteria, tag, constraints):
+        """Find element matches by its view tag
+        Espresso only
+        """
+        return self._filter_elements(
+            application.find_elements(by=AppiumBy.ANDROID_VIEWTAG, value=criteria),
+            tag, constraints)
+
+    def _find_by_android_data_matcher(self, application, criteria, tag, constraints):
+        """Find element matches by Android Data Matcher
+        Espresso only
+        """
+        return self._filter_elements(
+            application.find_elements(by=AppiumBy.ANDROID_DATA_MATCHER, value=criteria),
+            tag, constraints)
+
+    def _find_by_android_view_matcher(self, application, criteria, tag, constraints):
+        """Find element matches by  Android View Matcher
+        Espresso only
+        """
+        return self._filter_elements(
+            application.find_elements(by=AppiumBy.ANDROID_VIEW_MATCHER, value=criteria),
+            tag, constraints)
+
+    def _find_by_ios(self, application, criteria, tag, constraints):
+        """Find element matches by UI Automation."""
+        return self._filter_elements(
+            application.find_elements(by=AppiumBy.IOS_UIAUTOMATION, value=criteria),
+            tag, constraints)
+
+    def _find_by_ios_predicate(self, application, criteria, tag, constraints):
+        """Find element matches by  iOSNsPredicateString."""
+        return self._filter_elements(
+            application.find_elements(by=AppiumBy.IOS_PREDICATE, value=criteria),
+            tag, constraints)
+
+    def _find_by_chain(self, application, criteria, tag, constraints):
+        """Find element matches by  iOSChainString."""
+        return self._filter_elements(
+            application.find_elements(by=AppiumBy.IOS_CLASS_CHAIN, value=criteria),
+            tag, constraints)
+
+    def _find_by_default(self, application, criteria, tag, constraints):
+        if self._is_xpath(criteria):
+            return self._find_by_xpath(application, criteria, tag, constraints)
+        # Used `id` instead of _find_by_key_attrs since iOS and Android internal `id` alternatives are
+        # different and inside appium python client. Need to expose these and improve in order to make
+        # _find_by_key_attrs useful.
+        return self._find_by_id(application, criteria, tag, constraints)
+
+    # TODO: Not in use after conversion from Selenium2Library need to make more use of multiple auto selector strategy
+    def _find_by_key_attrs(self, application, criteria, tag, constraints):
+        key_attrs = self._key_attrs.get(None)
+        if tag is not None:
+            key_attrs = self._key_attrs.get(tag, key_attrs)
+
+        xpath_criteria = utils.escape_xpath_value(criteria)
+        xpath_tag = tag if tag is not None else '*'
+        xpath_constraints = ["@%s='%s'" % (name, constraints[name]) for name in constraints]
+        xpath_searchers = ["%s=%s" % (attr, xpath_criteria) for attr in key_attrs]
+        xpath_searchers.extend(
+            self._get_attrs_with_url(key_attrs, criteria, application))
+        xpath = "//%s[%s(%s)]" % (
+            xpath_tag,
+            ' and '.join(xpath_constraints) + ' and ' if len(xpath_constraints) > 0 else '',
+            ' or '.join(xpath_searchers))
+        return self._normalize_result(application.find_elements(by=AppiumBy.XPATH, value=xpath))
+
+    # Private
+    _key_attrs = {
+        None: ['@id', '@name'],
+        'a': ['@id', '@name', '@href', 'normalize-space(descendant-or-self::text())'],
+        'img': ['@id', '@name', '@src', '@alt'],
+        'input': ['@id', '@name', '@value', '@src'],
+        'button': ['@id', '@name', '@value', 'normalize-space(descendant-or-self::text())']
+    }
+
+    def _get_tag_and_constraints(self, tag):
+        if tag is None:
+            return None, {}
+
+        tag = tag.lower()
+        constraints = {}
+        if tag == 'link':
+            tag = 'a'
+        elif tag == 'image':
+            tag = 'img'
+        elif tag == 'list':
+            tag = 'select'
+        elif tag == 'radio button':
+            tag = 'input'
+            constraints['type'] = 'radio'
+        elif tag == 'checkbox':
+            tag = 'input'
+            constraints['type'] = 'checkbox'
+        elif tag == 'text field':
+            tag = 'input'
+            constraints['type'] = 'text'
+        elif tag == 'file upload':
+            tag = 'input'
+            constraints['type'] = 'file'
+        return tag, constraints
+
+    def _element_matches(self, element, tag, constraints):
+        if not element.tag_name.lower() == tag:
+            return False
+        for name in constraints:
+            if not element.get_attribute(name) == constraints[name]:
+                return False
+        return True
+
+    def _filter_elements(self, elements, tag, constraints):
+        elements = self._normalize_result(elements)
+        if tag is None:
+            return elements
+        return filter(
+            lambda element: self._element_matches(element, tag, constraints),
+            elements)
+
+    def _get_attrs_with_url(self, key_attrs, criteria, browser):
+        attrs = []
+        url = None
+        xpath_url = None
+        for attr in ['@src', '@href']:
+            if attr in key_attrs:
+                if url is None or xpath_url is None:
+                    url = self._get_base_url(browser) + "/" + criteria
+                    xpath_url = utils.escape_xpath_value(url)
+                attrs.append("%s=%s" % (attr, xpath_url))
+        return attrs
+
+    def _get_base_url(self, browser):
+        url = browser.get_current_url()
+        if '/' in url:
+            url = '/'.join(url.split('/')[:-1])
+        return url
+
+    def _parse_locator(self, locator):
+        prefix = None
+        criteria = locator
+        if not self._is_xpath(locator):
+            locator_parts = locator.partition('=')
+            if len(locator_parts[1]) > 0:
+                prefix = locator_parts[0].strip().lower()
+                criteria = locator_parts[2].strip()
+        return (prefix, criteria)
+
+    def _is_xpath(self, locator):
+        return locator and locator.startswith('/')
+
+    def _normalize_result(self, elements):
+        if not isinstance(elements, list):
+            logger.debug("WebDriver find returned %s" % elements)
+            return []
+        return elements

AppiumLibrary/utils/__init__.py

@@ -0,0 +1,50 @@
+import os
+from pathlib import Path
+
+from robot.utils import abspath
+
+from .applicationcache import ApplicationCache
+
+
+def escape_xpath_value(value):
+    value = str(value)
+    if '"' in value and '\'' in value:
+        parts_wo_apos = value.split('\'')
+        return "concat('%s')" % "', \"'\", '".join(parts_wo_apos)
+    if '\'' in value:
+        return "\"%s\"" % value
+    return "'%s'" % value
+
+
+def read_file(file_path):
+    with open(_absnorm(file_path), encoding='UTF-8', errors='strict', newline="") as f:
+        file_content = f.read().replace("\r\n", "\n")
+    return file_content
+
+
+def _absnorm(path):
+    return abspath(_normalize_path(path))
+
+
+def _normalize_path(path, case_normalize=False):
+    """Normalizes the given path.
+
+    - Collapses redundant separators and up-level references.
+    - Converts ``/`` to ``\\`` on Windows.
+    - Replaces initial ``~`` or ``~user`` by that user's home directory.
+    - Converts ``pathlib.Path`` instances to ``str``.
+    On Windows result would use ``\\`` instead of ``/`` and home directory
+    would be different.
+    """
+    if isinstance(path, Path):
+        path = str(path)
+    else:
+        path = path.replace("/", os.sep)
+    path = os.path.normpath(os.path.expanduser(path))
+    # os.path.normcase doesn't normalize on OSX which also, by default,
+    # has case-insensitive file system. Our robot.utils.normpath would
+    # do that, but it's not certain would that, or other things that the
+    # utility do, desirable.
+    if case_normalize:
+        path = os.path.normcase(path)
+    return path or "."

AppiumLibrary/utils/applicationcache.py

@@ -0,0 +1,48 @@
+from robot.utils import ConnectionCache
+
+
+class ApplicationCache(ConnectionCache):
+
+    def __init__(self):
+        ConnectionCache.__init__(self, no_current_msg='No current application')
+        self._closed = set()
+
+    @property
+    def applications(self):
+        return self._connections
+
+    def get_open_browsers(self):
+        open_applications = []
+        for application in self._connections:
+            if application not in self._closed:
+                open_applications.append(application)
+        return open_applications
+
+    def close(self, ignore_fail=False, quit_app=True):
+        if self.current:
+            application = self.current
+            try:
+                if quit_app:
+                    application.quit()
+                else:
+                    application.close()
+            except Exception as err:
+                if not ignore_fail:
+                    raise err
+            self.current = self._no_current
+            self.current_index = None
+            self._closed.add(application)
+
+    def close_all(self, ignore_fail=True, quit_app=True):
+        for application in self._connections:
+            if application not in self._closed:
+                try:
+                    if quit_app:
+                        application.quit()
+                    else:
+                        application.close()
+                except Exception as err:
+                    if not ignore_fail:
+                        raise err
+        self.empty_cache()
+        return self.current

AppiumLibrary/version.py

@@ -0,0 +1,2 @@
+# -*- coding: utf-8 -*-
+VERSION = '3.0-beta'

robotframework_appiumwindows-0.1.0.dist-info/METADATA

@@ -0,0 +1,148 @@
+Metadata-Version: 2.4
+Name: robotframework-appiumwindows
+Version: 0.1.0
+Summary: Robot Framework AppiumLibrary extension for Windows desktop automation using NovaWindows Driver instead of WinAppDriver.
+Author-email: Huy Nguyen <nguyenvanhuy0612@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/nguyenvanhuy0612/robotframework-appiumwindows
+Project-URL: Repository, https://github.com/nguyenvanhuy0612/robotframework-appiumwindows
+Project-URL: Issues, https://github.com/nguyenvanhuy0612/robotframework-appiumwindows/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Robot Framework
+Classifier: Framework :: Robot Framework :: Library
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Testing
+Classifier: Topic :: Software Development :: Quality Assurance
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: robotframework>=7.3.2
+Requires-Dist: Appium-Python-Client>=5.1.1
+Dynamic: license-file
+
+# Robot Framework AppiumLibrary Compatible with NovaWindows Driver
+
+---
+
+## Overview
+This library extends [AppiumLibrary](https://github.com/serhatbolsu/robotframework-appiumlibrary) to provide compatibility with the **NovaWindows Driver** for Appium 2.x.  
+
+It allows you to automate Windows desktop applications using **Robot Framework** with minimal setup.  
+
+---
+
+> **Note**
+>
+> - NovaWindows Driver currently uses a **PowerShell session** as its back-end.  
+>   - No Developer Mode required  
+>   - No extra dependencies required  
+> - A future update is planned to move to a **.NET-based backend** for:  
+>   - Improved reliability  
+>   - Better error handling  
+>   - More feature support beyond PowerShell limitations  
+>
+> Reference: [AutomateThePlanet/appium-novawindows-driver](https://github.com/AutomateThePlanet/appium-novawindows-driver)
+
+---
+
+## Installation
+
+### 1. On the **Test Runner (local machine)**
+
+Install the Robot Framework library:
+
+```bash
+pip install robotframework-appiumwindows
+```
+
+> This is the only requirement on the machine where you run Robot Framework tests.  
+> No need to install Node.js or Appium here.
+
+---
+
+### 2. On the **Target Machine (remote machine under test)**
+
+This is where the Appium server and NovaWindows driver must be installed.
+
+1. Install **Node.js**  
+   [Download Node.js](https://nodejs.org/en/download)  
+
+2. Install **Appium** globally:  
+   ```bash
+   npm install -g appium
+   ```
+
+3. Install **NovaWindows Driver**:  
+   ```bash
+   appium driver install --source=npm appium-novawindows-driver
+   ```
+
+4. Start the Appium server:  
+   ```bash
+   appium --relaxed-security
+   ```
+   (use `--relaxed-security` if you plan to execute PowerShell commands)
+
+---
+
+## Example Test
+
+```robot
+*** Settings ***
+Library    AppiumLibrary
+
+Test Setup       Open Root Session
+Test Teardown    Appium Close All Applications
+
+
+*** Test Cases ***
+Type To Notepad
+    [Documentation]    Launch Notepad, type text, and close without saving
+    Appium Execute Powershell Command    Start-Process "notepad"
+    Appium Input    class=Notepad    This is example{enter 3}Close without save
+    Appium Click    //Window[@ClassName='Notepad']//Button[@Name='Close']
+    Appium Click    name=Don't Save
+
+
+*** Keywords ***
+Open Root Session
+    ${parameters}=    Create Dictionary
+    ...    remote_url=http://<TARGET_MACHINE_IP>:4723
+    ...    platformName=Windows
+    ...    appium:app=Root
+    ...    appium:automationName=NovaWindows
+    ...    appium:newCommandTimeout=30
+    Open Application    &{parameters}
+```
+
+---
+
+## Architecture
+
+```text
++--------------------------+         +----------------------------+
+|  Test Runner (Local PC)  |         |  Target Machine (Windows)  |
+|--------------------------|         |----------------------------|
+| - Robot Framework        |         | - Node.js                  |
+| - robotframework-        |  --->   | - Appium 2.x               |
+|   appium-windows (pip)   |         | - NovaWindows Driver       |
++--------------------------+         +----------------------------+
+```
+
+---
+
+## References
+
+- [Appium](https://appium.io/)  
+- [Robot Framework](https://robotframework.org/)  
+- [AppiumLibrary](https://github.com/serhatbolsu/robotframework-appiumlibrary)  
+- [NovaWindows Driver](https://github.com/AutomateThePlanet/appium-novawindows-driver)  
+
+---

robotframework_appiumwindows-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+AppiumLibrary/__init__.py,sha256=_8Mcsywy1P1ebzUl0Cn49RCLSHzG4zRrFQTNAL1r_2o,5901
+AppiumLibrary/appium_path.py,sha256=0LZFLn07dsxOY0FIJ4REEfyRbNBxtgNzX-rEfovEh_4,260
+AppiumLibrary/version.py,sha256=hrqXUu4slpU-usm7Rv3LJhMR6paooe0eSmHZXr8iYHY,47
+AppiumLibrary/keywords/__init__.py,sha256=vRZLNwHfUSaBPBY3dmDUejCihFL0N2ODYkrubhBwcjA,767
+AppiumLibrary/keywords/_applicationmanagement.py,sha256=qJYKpNjHEcNvXlWVfKIh-xCUkWJGyDTWigl2-nAJSMk,19786
+AppiumLibrary/keywords/_element.py,sha256=MsY69h0ZiRc8Tl6K4KU56k8fgWHv4WeHwIGm_h68TTE,53655
+AppiumLibrary/keywords/_logging.py,sha256=r9P56w85BFQIZw3pMQtFliu7uD4sqoCITDXDhB_LURM,1927
+AppiumLibrary/keywords/_powershell.py,sha256=j_-LrLIOkx6sdKj-P-bUerfcdpHIC_fIG4VZT4G2Ovo,23611
+AppiumLibrary/keywords/_runonfailure.py,sha256=t6kJrVJdCo9cHbuUUs1Qoy63Z7AKTrDBepOIxvsSNDQ,2921
+AppiumLibrary/keywords/_screenrecord.py,sha256=e8EXHTwiujeQVMrDhmYq6QIQk3MwSuuFpu8SWHZ0r7Q,6927
+AppiumLibrary/keywords/_screenshot.py,sha256=L_o1ncYsJ_ghJEVrNVlilXCxvkR9KyR7D-twZIAmEAQ,3998
+AppiumLibrary/keywords/_waiting.py,sha256=vDp7duuVuRsmtpf4DYgyvP363KpG9Ldffr2TD3GqTcI,6446
+AppiumLibrary/keywords/_windows.py,sha256=W7M5ba1IZ7YdAn3CPP58fq-CrBC_Ck-GaKXVh7dJjFE,9666
+AppiumLibrary/keywords/keywordgroup.py,sha256=SvgJNazRMZoyH4pBmGY_05l1FjVDaoVfwX6I3YN_fU0,2449
+AppiumLibrary/locators/__init__.py,sha256=-t6gBYeVN8LS1q_agwCNikDaH54v_JXPfRtE5slY9dg,109
+AppiumLibrary/locators/elementfinder.py,sha256=EdKVUJIHZCxrQkAu-0xp3yhCwA5qd5y55SnP58-dBP0,11241
+AppiumLibrary/utils/__init__.py,sha256=FlB2DCknRHFvtj4ZZbq3B0sSmZ9RTnvqucHNC9pReN4,1622
+AppiumLibrary/utils/applicationcache.py,sha256=AeeZIzRLxqcOLw9lIAir2_CypGAEwglCzzvMep4IQrg,1571
+robotframework_appiumwindows-0.1.0.dist-info/licenses/LICENSE,sha256=yVLQqHcOliLXZJC6M0K2u0WJL9yIW1u7d5bsM_qW1Es,1090
+robotframework_appiumwindows-0.1.0.dist-info/METADATA,sha256=HXX0laXT4t3XFysxHQL8Pr9G_bD6cs930X2-5Aux_iE,4902
+robotframework_appiumwindows-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+robotframework_appiumwindows-0.1.0.dist-info/top_level.txt,sha256=2o2iQDagXnzsewODgcttx95vTzvaYaZB7q6KJB8sf-I,14
+robotframework_appiumwindows-0.1.0.dist-info/RECORD,,

robotframework_appiumwindows-0.1.0.dist-info/WHEEL

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

robotframework_appiumwindows-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Nguyen Van Huy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

robotframework_appiumwindows-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+AppiumLibrary