Release - v1

fastrpa/__init__.py

@@ -1,11 +1,10 @@
 from fastrpa.app import FastRPA, Web
-from fastrpa.elements.form import Form
-from fastrpa.exceptions import ElementNotFound
+from fastrpa.exceptions import ElementNotFound, ElementNotFoundAfterTime
 
 
 __all__ = (
-    "FastRPA",
-    "Web",
-    "Form",
-    "ElementNotFound",
+    'FastRPA',
+    'Web',
+    'ElementNotFound',
+    'ElementNotFoundAfterTime',
 )

fastrpa/app.py

@@ -1,14 +1,13 @@
-from time import sleep
-from selenium.webdriver import Remote, ChromeOptions, ActionChains
-from selenium.webdriver.common.keys import Keys
+from selenium.webdriver import Remote, ChromeOptions
 from fastrpa.commons import (
-    get_element_text,
     get_browser_options,
-    wait_until_element_is_hidden,
-    wait_until_element_is_present,
-    VISIBILITY_TIMEOUT,
 )
-from fastrpa.elements.form import Form
+from fastrpa.settings import VISIBILITY_TIMEOUT
+from fastrpa.core.elements import Element
+
+from fastrpa.core.timer import Timer
+from fastrpa.core.keyboard import Keyboard
+from fastrpa.factories import ElementFactory
 from fastrpa.types import BrowserOptions, BrowserOptionsClass, WebDriver
 
 
@@ -19,44 +18,46 @@ def __init__(
         webdriver: WebDriver,
         visibility_timeout: int,
     ):
-        self.url = url
+        self._keyboard: Keyboard | None = None
+        self._timer: Timer | None = None
+        self.starter_url = url
         self.webdriver = webdriver
-        self.webdriver.get(url)
+        self.webdriver.get(self.starter_url)
+        self._element_factory = ElementFactory(self.webdriver)
         self.visibility_timeout = visibility_timeout
 
-    def reset(self):
-        self.webdriver.get(self.url)
-
-    def form(self, xpath: str) -> Form:
-        return Form(xpath, self.webdriver, self.visibility_timeout)
-
-    def read(self, xpath: str) -> str | None:
-        return get_element_text(self.webdriver, xpath, self.visibility_timeout)
-
-    def has_content(self, value: str) -> bool:
-        return value in self.webdriver.page_source
-
-    def wait_until_hide(self, xpath: str):
-        wait_until_element_is_hidden(self.webdriver, xpath)
+    @property
+    def url(self) -> str:
+        return self.webdriver.current_url
 
-    def wait_until_present(self, xpath: str):
-        wait_until_element_is_present(self.webdriver, xpath)
+    @property
+    def keyboard(self) -> Keyboard:
+        if self._keyboard:
+            return self._keyboard
+        self._keyboard = Keyboard(self.webdriver)
+        return self._keyboard
 
-    def wait_seconds(self, seconds: int):
-        sleep(seconds)
+    @property
+    def timer(self) -> Timer:
+        if self._timer:
+            return self._timer
+        self._timer = Timer(self.webdriver)
+        return self._timer
 
-    def press_esc(self):
-        ActionChains(self.webdriver).send_keys(Keys.ESCAPE).perform()
+    def reset(self):
+        self.webdriver.get(self.starter_url)
 
-    def press_enter(self):
-        ActionChains(self.webdriver).send_keys(Keys.ENTER).perform()
+    def element(self, xpath: str, wait: bool = True) -> Element:
+        if not wait:
+            return self._element_factory.get(xpath)
+        return self._element_factory.get_when_available(xpath, self.visibility_timeout)
 
-    def press_tab(self):
-        ActionChains(self.webdriver).send_keys(Keys.TAB).perform()
+    def has_content(self, value: str) -> bool:
+        return value in self.webdriver.page_source
 
 
 class FastRPA:
-    browser_arguments = ["--start-maximized", "--ignore-certificate-errors"]
+    browser_arguments = ['--start-maximized', '--ignore-certificate-errors']
 
     def __init__(
         self,

fastrpa/commons.py

@@ -1,23 +1,17 @@
 from selenium.webdriver import ChromeOptions
-from selenium.common.exceptions import TimeoutException, ElementNotInteractableException
 from selenium.webdriver.common.by import By
 from selenium.webdriver.support import expected_conditions
 from selenium.webdriver.support.ui import WebDriverWait
 from selenium.webdriver.remote.webelement import WebElement
-from selenium.webdriver.support.ui import Select
 
 import os
 import requests
 import mimetypes
 
-from fastrpa.exceptions import ElementNotFound
+from fastrpa.settings import HIDDEN_TIMEOUT
 from fastrpa.types import BrowserOptions, BrowserOptionsClass, WebDriver
 
 
-VISIBILITY_TIMEOUT = 10
-HIDDEN_TIMEOUT = 60
-
-
 def get_browser_options(
     options: list[str], options_class: BrowserOptionsClass = ChromeOptions
 ) -> BrowserOptions:
@@ -27,25 +21,6 @@ def get_browser_options(
     return instance
 
 
-def get_element(
-    webdriver_or_parent_node: WebDriver | WebElement,
-    xpath: str,
-    timeout: int = VISIBILITY_TIMEOUT,
-) -> WebElement:
-    try:
-        return WebDriverWait(webdriver_or_parent_node, timeout).until(
-            expected_conditions.presence_of_element_located((By.XPATH, xpath))
-        )
-
-    except ElementNotInteractableException:
-        return WebDriverWait(webdriver_or_parent_node, timeout).until(
-            expected_conditions.element_to_be_clickable((By.XPATH, xpath))
-        )
-
-    except TimeoutException:
-        raise ElementNotFound(xpath, timeout)
-
-
 def wait_until_element_is_hidden(
     webdriver_or_parent_node: WebDriver | WebElement,
     xpath: str,
@@ -66,37 +41,16 @@ def wait_until_element_is_present(
     )
 
 
-def get_select_element(
-    webdriver_or_parent_node: WebDriver | WebElement,
-    xpath: str,
-    timeout: int = VISIBILITY_TIMEOUT,
-) -> Select:
-    return Select(get_element(webdriver_or_parent_node, xpath, timeout))
-
-
-def get_element_text(
-    webdriver_or_parent_node: WebDriver | WebElement,
-    xpath: str,
-    timeout: int = VISIBILITY_TIMEOUT,
-) -> str | None:
-    element = get_element(webdriver_or_parent_node, xpath, timeout)
-    if element.text:
-        return element.text
-    elif value := element.get_attribute("value"):
-        return value
-    return None
-
-
 def get_file_path(path: str) -> str:
     if os.path.isfile(path):
         return path
 
     file_response = requests.get(path)
-    file_extension = mimetypes.guess_extension(file_response.headers["Content-Type"])
+    file_extension = mimetypes.guess_extension(file_response.headers['Content-Type'])
     file_hash = abs(hash(file_response.content))
-    download_path = f"/tmp/{file_hash}{file_extension}"
+    download_path = f'/tmp/{file_hash}{file_extension}'
 
-    with open(download_path, "wb") as file:
+    with open(download_path, 'wb') as file:
         file.write(file_response.content)
 
     return download_path