browser-toolkit 0.0.1a1__py3-none-any.whl

browser_toolkit/selenium_toolkit/selenium_toolkit.py

@@ -0,0 +1,408 @@
+import json
+import time
+from random import uniform
+from typing import Union, Type
+from dataclasses import dataclass
+from http.cookies import SimpleCookie
+
+from selenium.webdriver.chromium.webdriver import ChromiumDriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.support import expected_conditions as EC
+from selenium.webdriver.support.wait import WebDriverWait
+from selenium.common.exceptions import (
+    TimeoutException,
+    InvalidSessionIdException,
+    NoSuchElementException,
+    WebDriverException,
+)
+from selenium.webdriver.remote.webdriver import WebDriver, WebElement
+
+from browser_toolkit.selenium_toolkit.utils import create_locator
+from enum import StrEnum
+import functools
+
+
+class RequestType(StrEnum):
+    DOCUMENT = "Document"
+    XHR = "XHR"
+    IMAGE = "Image"
+    SCRIPT = "Script"
+    STYLESHEET = "Stylesheet"
+    FONT = "Font"
+    FETCH = "Fetch"
+    OTHER = "Other"
+
+
+@dataclass
+class Redirect:
+    url: str
+
+
+@dataclass
+class Request:
+    url: str
+    request_id: str
+    cookies: dict
+    headers: dict
+    redirect: Redirect = None
+    type: RequestType = None
+
+
+def auto_wait(func) -> Type["Response"]:
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        obj_wait_time = args[0]._wait_time_range
+        wait = uniform(*obj_wait_time)
+        time.sleep(wait)
+
+        return func(*args, **kwargs)
+
+    return wrapper
+
+
+class SeleniumToolKit:
+    _wait_time_range = (0, 0)
+
+    def __init__(self, driver):
+        self.__driver: Union[WebDriver, ChromiumDriver] = driver
+
+    @property
+    def driver(self) -> Union[WebDriver, ChromiumDriver]:
+        return self.__driver
+
+    def change_wait_time(self, range_time: tuple = (0, 0)):
+        first, last = range_time
+
+        if not (first >= 0 and last >= first):
+            raise ValueError(f"range_time must be a tuple with positive values")
+
+        self._wait_time_range = range_time
+
+    @auto_wait
+    def goto(self, url: str) -> None:
+        self.__driver.get(url=url)
+
+    def query_selector(self, query_selector: str, web_element: WebElement = None) -> Union[WebElement, None]:
+        """
+        :param query_selector: css or xpath
+        :param web_element:  If None is passed will perform the query selector in the whole page
+        """
+        if not query_selector:
+            raise ValueError("You need send a query_selector")
+
+        target = web_element if web_element else self.__driver
+
+        if query_selector[0] == "/":
+            web_element = target.find_element(By.XPATH, query_selector)
+        else:
+            web_element = target.find_element(By.CSS_SELECTOR, query_selector)
+
+        return web_element
+
+    def query_selector_all(self, query_selector: str, web_element: WebElement = None) -> Union[list[WebElement], None]:
+        """
+        :param query_selector: css or xpath
+        :param web_element:  If None is passed will perform the query selector in the whole page
+        """
+        if not query_selector:
+            raise ValueError("You need send a query_selector")
+
+        target = web_element if web_element else self.__driver
+
+        if query_selector[0] == "/":
+            web_elements = target.find_elements(By.XPATH, query_selector)
+        else:
+            web_elements = target.find_elements(By.CSS_SELECTOR, query_selector)
+
+        return web_elements
+
+    def find_element_by_text(self, text: str):
+        query_selector = f"//*[contains(text(), '{text}' )]"
+        web_element = self.query_selector(query_selector=query_selector)
+        return web_element
+
+    def find_elements_by_text(self, text: str):
+        query_selector = f"//*[contains(text(), '{text}' )]"
+        web_element = self.query_selector_all(query_selector=query_selector)
+        return web_element
+
+    def find_element_by_tag_and_text(self, tag: str, text: str):
+        query_selector = f"//{tag}[contains(text(), '{text}' )]"
+        web_elements = self.query_selector(query_selector=query_selector)
+        return web_elements
+
+    def find_elements_by_tag_and_text(self, tag: str, text: str):
+        query_selector = f"//{tag}[contains(text(), '{text}' )]"
+        web_elements = self.query_selector_all(query_selector=query_selector)
+        return web_elements
+
+    def get_text(self, query_selector: str) -> str:
+        try:
+            return self.query_selector(query_selector=query_selector).text
+        except NoSuchElementException as e:
+            raise e
+
+    def get_attribute(self, query_selector: str, attribute: str) -> str:
+        try:
+            return self.query_selector(query_selector=query_selector).get_attribute(attribute)
+        except NoSuchElementException as e:
+            raise e
+
+    @auto_wait
+    def click(self, query_selector: str) -> None:
+        self.query_selector(query_selector=query_selector).click()
+
+    @auto_wait
+    def fill(self, text: str, query_selector: str) -> None:
+        element = self.query_selector(query_selector=query_selector)
+        element.send_keys(text)
+
+    @auto_wait
+    def clear(self, query_selector: str) -> None:
+        self.query_selector(query_selector=query_selector).clear()
+
+    def fill_in_random_time(self, text: str, query_selector: str) -> None:
+        element = self.query_selector(query_selector=query_selector)
+        for letter in text:
+            time.sleep(uniform(0.3, 0.8))
+            element.send_keys(letter)
+
+    def clear_and_fill(self, text: str, query_selector: str, random_time=False) -> None:
+        self.clear(query_selector=query_selector)
+        if random_time:
+            self.fill_in_random_time(text=text, query_selector=query_selector)
+        else:
+            self.fill(text=text, query_selector=query_selector)
+
+    def element_is_present(self, wait_time: int, query_selector: str) -> bool:
+        try:
+            WebDriverWait(self.__driver, wait_time).until(
+                EC.presence_of_element_located(create_locator(query_selector))
+            )
+            return True
+        except TimeoutException:
+            return False
+
+    def element_is_visible(self, wait_time: int, query_selector: str) -> bool:
+        try:
+            WebDriverWait(self.__driver, wait_time).until(
+                EC.visibility_of_element_located(create_locator(query_selector))
+            )
+            return True
+        except TimeoutException:
+            return False
+
+    def element_is_invisible(self, wait_time: int, query_selector: str) -> bool:
+        try:
+            WebDriverWait(self.__driver, wait_time).until(
+                EC.invisibility_of_element_located(create_locator(query_selector))
+            )
+            return True
+        except TimeoutException:
+            return False
+
+    def element_is_clickable(self, wait_time: int, query_selector: str) -> bool:
+        try:
+            WebDriverWait(self.__driver, wait_time).until(EC.element_to_be_clickable(create_locator(query_selector)))
+            return True
+        except TimeoutException:
+            return False
+
+    def text_is_present(self, wait_time: int, query_selector: str, text: str) -> bool:
+        try:
+            WebDriverWait(self.__driver, wait_time).until(
+                EC.text_to_be_present_in_element(create_locator(query_selector), text_=text)
+            )
+            return True
+        except TimeoutException:
+            return False
+
+    def alert_is_present(self, wait_time: int, message: str) -> bool:
+        try:
+            WebDriverWait(self.__driver, wait_time).until(EC.alert_is_present(), message=message)
+            return True
+        except TimeoutException:
+            return False
+
+    def page_is_loading(self) -> bool:
+        if self.__driver.execute_script("return document.readyState") != "complete":
+            return True
+        else:
+            return False
+
+    def block_urls(self, urls: list) -> None:
+        if not isinstance(self.__driver, ChromiumDriver):
+            TypeError("Your driver must be a ChromiumDriver type to use this method")
+
+        self.execute_cdp_cmd("Network.setBlockedURLs", {"urls": urls})
+        self.execute_cdp_cmd("Network.enable", {})
+
+    def driver_hard_refresh(self) -> None:
+        self.__driver.execute_script("location.reload(true)")
+
+    def webdriver_is_open(self) -> bool:
+        try:
+            self.__driver.execute_script("console.log('ola eu estou funcionando');")
+            return True
+        except InvalidSessionIdException:
+            return False
+
+    def get_all_requests(self) -> list[dict]:
+        """
+        !!! ALERT !!!
+        For this method works the code below is necessary in the driver's creation
+
+        # selenium < 4.0
+        capabilities = DesiredCapabilities.CHROME
+        capabilities["goog:loggingPrefs"] = {"performance": "ALL"}
+        driver = webdriver.Chrome(desired_capabilities=capabilities
+
+        # selenium > 4.0
+        capabilities = {"performance": "ALL"}
+        options.set_capability("goog:loggingPrefs", capabilities)
+        """
+
+        if not isinstance(self.__driver, ChromiumDriver):
+            TypeError("Your driver must be a ChromiumDriver type to use this method")
+
+        logs_raw = self.__driver.get_log("performance")
+        parsed_logs = [json.loads(lr["message"])["message"] for lr in logs_raw]
+        return parsed_logs
+
+    def get_requests(self, request_url: str) -> list[Request] | None:
+        parsed_logs = self.get_all_requests()
+        methods = [
+            "Network.responseReceived",
+            "Network.requestWillBeSent",
+            "Network.requestWillBeSentExtraInfo",
+            # "Page.windowOpen"  # I Only see in Redirect, maybe add in the future, does not have request_id
+        ]
+        received_response_list = [response for response in parsed_logs if response["method"] in methods]
+
+        resp_url = None
+        matched_requests_id = set()
+        for response in received_response_list:
+            urls_to_match = []
+            params = response["params"]
+            target_request_id = params.get("requestId")
+            if params.get("request"):
+                urls_to_match.append(params["request"]["url"])
+            if params.get("response"):
+                urls_to_match.append(params["response"]["url"])
+            if params.get("redirectResponse"):
+                urls_to_match.append(params["redirectResponse"]["url"])
+
+            for url in urls_to_match:
+                if request_url in url:
+                    matched_requests_id.add(target_request_id)
+
+        if not matched_requests_id:
+            return None
+
+        matched_requests = []
+        for target_request_id in matched_requests_id:
+            cookies = dict()
+            headers = dict()
+            url: str = None
+            redirect = None
+            request_type: RequestType = None
+            for response in received_response_list:
+                params = response["params"]
+                request_id = params.get("requestId")
+                method = response.get("method")
+
+                if target_request_id == request_id:
+                    if method == "Network.requestWillBeSentExtraInfo":
+                        headers = params.get("headers")
+
+                        cookies_string = headers.get("cookie")
+                        if not cookies_string:
+                            continue
+
+                        cookie_parser = SimpleCookie()
+                        cookie_parser.load(cookies_string)
+                        cookies = dict(cookie_parser)
+
+                    if method == "Network.requestWillBeSent":
+                        url = params["request"]["url"]
+                        request_type = RequestType(params["type"])
+
+                        if params.get("redirectResponse"):
+                            redirect_url = params["redirectResponse"]["url"]
+                            if request_url in redirect_url:
+                                redirect = Redirect(url=redirect_url)
+
+            request_data = Request(
+                url=url,
+                request_id=target_request_id,
+                cookies=cookies,
+                headers=headers,
+                redirect=redirect,
+                type=request_type,
+            )
+            matched_requests.append(request_data)
+
+        return matched_requests
+
+    def response_data_from_request(self, request_url: str, request_id: str = None) -> str | None:
+        if request_id:
+            response_body = self.execute_cdp_cmd("Network.getResponseBody", {"requestId": request_id})
+            return response_body
+
+        received_requests = self.get_requests(request_url=request_url)
+        if not received_requests:
+            return None
+
+        if len(received_requests) > 1:
+            raise ValueError("more than one request matched")
+
+        return self.get_response_body_from_request_id(request_id=received_requests[0].request_id)
+
+    def get_response_body_from_request_id(self, request_id: str = None) -> str | None:
+        try:
+            response_body = self.execute_cdp_cmd(cmd="Network.getResponseBody", cmd_args={"requestId": request_id})
+        except WebDriverException:
+            return None
+
+        return response_body
+
+    # def execute_cdp_cmd(self, cmd: str, cmd_args: dict) -> str:
+    #     execute_command = {'method': cmd, 'params': cmd_args}
+    #     async def execute_cdp_async():
+    #         async with self.__driver.bidi_connection() as session:
+    #             cdp_session = session.session
+    #             return await cdp_session.execute(execute_command)
+    #
+    #     return trio.run(execute_cdp_async)
+
+    def execute_cdp_cmd(self, cmd: str, cmd_args: dict) -> str:
+        """
+        Useful for when executing CDP command in a remote driver
+        """
+        resource = "/session/%s/chromium/send_command_and_get_result" % self.__driver.session_id
+        url = self.__driver.command_executor._url + resource
+        body = json.dumps({"cmd": cmd, "params": cmd_args})
+        response = self.__driver.command_executor._request("POST", url, body)
+        return response.get("value")
+
+    def scroll_window(self, query_selector: str = None, web_element: WebElement = None) -> None:
+        """
+        Scrolls window to element position
+        """
+        assert query_selector or web_element, "You need to provide query_selector or web_element"
+
+        if web_element is None:
+            web_element = self.query_selector(query_selector=query_selector)
+
+        js_code = "arguments[0].scrollIntoView();"
+        self.__driver.execute_script(js_code, web_element)
+
+    def get_all_local_storage(
+        self,
+    ) -> dict:
+        return self.__driver.execute_script(f"return window.localStorage")
+
+    def quit(self):
+        if self.webdriver_is_open():
+            self.__driver.quit()
+            return

browser_toolkit/selenium_toolkit/utils.py

@@ -0,0 +1,10 @@
+from selenium.webdriver.common.by import By
+
+
+def create_locator(query_selector: str) -> tuple:
+    if query_selector[0] == "/":
+        locator = (By.XPATH, query_selector)
+    else:
+        locator = (By.CSS_SELECTOR, query_selector)
+
+    return locator

browser_toolkit/types.py

@@ -0,0 +1,49 @@
+from dataclasses import dataclass
+from enum import StrEnum
+from typing import Literal
+
+from pydantic import BaseModel
+
+
+class Cookie(BaseModel):
+    name: str
+    value: str
+    url: str | None = None
+    domain: str | None = None
+    path: str | None = None
+    expires: float | None = None
+    httpOnly: bool | None = None
+    secure: bool | None = None
+    sameSite: Literal["Lax", "None", "Strict"] | None = None
+    partitionKey: str | None | None = None
+
+
+class LocalStorage(BaseModel):
+    key: str
+    value: str
+
+
+class RequestType(StrEnum):
+    DOCUMENT = "Document"
+    XHR = "XHR"
+    IMAGE = "Image"
+    SCRIPT = "Script"
+    STYLESHEET = "Stylesheet"
+    FONT = "Font"
+    FETCH = "Fetch"
+    OTHER = "Other"
+
+
+@dataclass
+class Redirect:
+    url: str
+
+
+@dataclass
+class Request:
+    url: str
+    request_id: str
+    cookies: dict
+    headers: dict
+    redirect: Redirect = None
+    type: RequestType = None

browser_toolkit/utils.py

@@ -0,0 +1,2 @@
+def raise_not_implemented():
+    raise NotImplementedError("This method is not implemented yet.")

browser_toolkit-0.0.1a1.dist-info/METADATA

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: browser-toolkit
+Version: 0.0.1a1
+Summary: Toolkit that provides a single inteface to interact with different browser automations.
+Project-URL: Homepage, https://github.com/toriium/browser-toolkit
+Project-URL: Documentation, https://github.com/toriium/browser-toolkit/blob/master/README.md
+Project-URL: Repository, https://github.com/toriium/browser-toolkit
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: camoufox>=0.4.11
+Requires-Dist: playwright>=1.60.0
+Requires-Dist: pydantic>=2.13.4
+Requires-Dist: pydoll-python>=2.23.0
+Requires-Dist: selenium>=4.44.0
+Dynamic: license-file
+
+# browser-toolkit
+
+Browser Toolkit that provides a single inteface to interact with different browser automations.
+
+
+Supported automations include:
+- Selenium
+- Playwright
+- Camoufox (Via Playwright implementation)
+- Pydoll
+
+Features that currently browser-toolkit can offer:
+
+- **Async First**
+- **More legible automation code**
+- **Abstractions of browsers methods**
+- **Helpful tools to use when interacting with browsers**
+
+
+
+## Install
+```
+# Pip
+pip install browser-toolkit
+
+# Uv
+uv add browser-toolkit
+
+# Poetry
+poetry add browser-toolkit
+```
+
+## Basic
+```python
+from playwright.async_api import async_playwright
+from browser_toolkit.playwright import PlaywrightTollKit
+import asyncio
+
+async def main():
+    # Create an instance
+    async with async_playwright() as p:
+        browser = await p.chromium.launch()
+        page = await browser.new_page()
+
+        # Pass instance to BrowserToolKit
+        btk = PlaywrightTollKit(browser=browser, page=page)
+        
+        # Navigate to a website
+        await btk.goto('https://www.example.com')
+        
+        # Create a selector
+        se_class = '.class1'
+        
+        # Use BrowserToolKit to find a web element
+        web_element = await btk.selector(selector=se_class)
+    
+        # With returned web_element use click() method
+        await web_element.click()
+        
+        # Or you can click directly with BrowserToolKit
+        await btk.click(selector=se_class)
+        
+        # close instance with BrowserToolKit
+        await btk.close()
+
+if __name__ == "__main__":
+    asyncio.run(main())
+```

browser_toolkit-0.0.1a1.dist-info/RECORD

@@ -0,0 +1,17 @@
+browser_toolkit/__init__.py,sha256=qZqNWgYPpJ7s1XTysTwSXHWDy74VpNgUyUMyRkutR0Y,104
+browser_toolkit/base_toolkit.py,sha256=BTXO43T2OypYkSthv3XsqUQPUOMVvlIHfjwpAAys9P4,16834
+browser_toolkit/camoufox.py,sha256=63--CS3R6yoGPjBdGYWf6HwCaqdtPqcTG_bwXTCpE0I,329
+browser_toolkit/playwright.py,sha256=wFkTz1k1Fok5kJ3tJ2qL6O0F72dgbjGps4Ul4O-Lrrk,17229
+browser_toolkit/selenium.py,sha256=LiG7qjivKJeusbhPYVp3nAre0Ak4MbPLtjwiUDrWWq8,13979
+browser_toolkit/types.py,sha256=6oVgNX91jB7SwX_9hp8l9W4fuc3CK4AePHIqhUglIfo,921
+browser_toolkit/utils.py,sha256=w0BAZrVStdQbUF-pqCmTq7QVr6b9NEWtryE3EsWTCIk,98
+browser_toolkit/create_browser/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+browser_toolkit/create_browser/playwright.py,sha256=NPBxXR5N82Q19q2HfgmrKXm8ovwQVkIF15SdWsaoM28,829
+browser_toolkit/selenium_toolkit/__init__.py,sha256=4YBJs0Jk3YzsCEZgSmG8zj2H331m3JwEdsr_7JR0xoc,46
+browser_toolkit/selenium_toolkit/selenium_toolkit.py,sha256=b5eOG2WOlYWqnYlXAasNf_KJnF0iZ0i4ZYCKlBJw0Nc,14781
+browser_toolkit/selenium_toolkit/utils.py,sha256=BIYd06r5hYcrDhfXsoR3SOKsP7pe-sRS2ePj5L721bI,256
+browser_toolkit-0.0.1a1.dist-info/licenses/LICENSE,sha256=gXf5dRMhNSbfLPYYTY_5hsZ1r7UU1OaKQEAQUhuIBkM,18092
+browser_toolkit-0.0.1a1.dist-info/METADATA,sha256=Tft7T03QTUX3HkT3ca7u9XDfINpTWWACflkqfdKBXFQ,2238
+browser_toolkit-0.0.1a1.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+browser_toolkit-0.0.1a1.dist-info/top_level.txt,sha256=zELYpWop-qpcptMW6T_bAI2CadBZP7z3N58YYW3fk7c,16
+browser_toolkit-0.0.1a1.dist-info/RECORD,,

browser_toolkit-0.0.1a1.dist-info/WHEEL

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