autoflex 1.0.0__tar.gz

autoflex-1.0.0/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: autoflex
+Version: 1.0.0
+Summary: Web and System Automation Testing Framework
+Home-page: https://github.com/LZYEIL/AutoFlex
+Author: Zhiyuan Li
+Author-email: zhiyuanjeremy@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: selenium>=4.24.0
+Requires-Dist: pyautogui>=0.9.54
+Requires-Dist: pynput>=1.8.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# This is AutoFlex README Template

autoflex-1.0.0/README.md

@@ -0,0 +1 @@
+# This is AutoFlex README Template

autoflex-1.0.0/autoflex/core/actions.py

@@ -0,0 +1,446 @@
+from .selenium_actions import (
+    element_actions as selenium_element,
+    dropdown_actions as selenium_dropdown,
+    page_actions as selenium_page,
+    mouse_actions as selenium_mouse,
+    wait_actions as selenium_wait,
+    script_actions as selenium_script,
+    screenshot_actions as selenium_screenshot
+)
+from .pyautogui_actions import (
+    mouse_actions as pyauto_mouse,
+    keyboard_actions as pyauto_keyboard,
+    screen_actions as pyauto_screen,
+    dialog_actions as pyauto_dialog
+)
+from .pynput_actions import (
+    keyboard_controller as pynput_keyboard,
+    keyboard_listener as pynput_kb_listener,
+    mouse_listener as pynput_mouse_listener
+)
+from .logger import logger
+from .exceptions import OperationTimeoutError
+
+
+
+
+class Actions:
+
+
+    # Here are the functions from the Selenium:
+    @staticmethod
+    def find_element(locator, timeout=10):
+        element = selenium_element.ElementActions.find_element(locator, timeout)
+        return element
+
+
+
+
+    # Click: Supports switching to PyAutoGUI
+    @staticmethod
+    def click(locator=None, x=None, y=None, timeout=10):
+        if locator:
+            try:
+                selenium_element.ElementActions.click(locator, timeout)
+                logger.info(f"Click via Selenium: {locator}")
+                return
+            except Exception as e:
+                logger.warning(f"Selenium click failed: {e}, fallback to PyAutoGUI.")
+        if x is not None and y is not None:
+            try:
+                pyauto_mouse.MouseActions.click_at(x, y)
+                logger.info(f"Click at ({x},{y}) via PyAutoGUI")
+                return
+            except Exception as e:
+                logger.error(f"PyAutoGUI click failed: {e}")
+        raise OperationTimeoutError("Click failed.")
+
+
+
+
+    @staticmethod
+    def input_text(locator, text, timeout=10):
+        try:
+            selenium_element.ElementActions.input_text(locator, text, timeout)
+            logger.info(f"Input text via Selenium on {locator}: {text}")
+        except Exception as e:
+            logger.error(f"Input text on {locator} failed: {e}")
+            raise OperationTimeoutError("Input text failed.")
+
+
+
+
+    @staticmethod
+    def get_text(locator, timeout=10):
+        try:
+            text = selenium_element.ElementActions.get_text(locator, timeout)
+            logger.info(f"Get text via Selenium from {locator}: {text}")
+            return text
+        except Exception as e:
+            logger.error(f"Get text from {locator} failed: {e}")
+            raise OperationTimeoutError("Get text failed.")
+
+
+
+
+    @staticmethod
+    def get_attribute(locator, attr, timeout=10):
+        try:
+            value = selenium_element.ElementActions.get_attribute(locator, attr, timeout)
+            logger.info(f"Get attribute '{attr}' from {locator}: {value}")
+            return value
+        except Exception as e:
+            logger.error(f"Get attribute {attr} from {locator} failed: {e}")
+            raise OperationTimeoutError("Get attribute failed.")
+
+
+
+
+    @staticmethod
+    def is_visible(locator, timeout=10):
+        visible = selenium_element.ElementActions.is_visible(locator, timeout)
+        return visible
+
+
+
+
+    @staticmethod
+    def move_to_element(locator, timeout=10):
+        try:
+            selenium_mouse.MouseActions.move_to_element(locator, timeout)
+            logger.info(f"Moved to element via Selenium: {locator}")
+        except Exception as e:
+            logger.error(f"Move to {locator} failed: {e}")
+            raise OperationTimeoutError("Move to element failed.")
+
+
+
+
+    # double_click supports switching to PyAutoGUI
+    @staticmethod
+    def double_click(locator=None, x=None, y=None, timeout=10):
+        if locator:
+            try:
+                selenium_mouse.MouseActions.double_click(locator, timeout)
+                logger.info(f"Double click via Selenium: {locator}")
+                return
+            except Exception as e:
+                logger.warning(f"Selenium double click failed: {e}, fallback.")
+        if x is not None and y is not None:
+            try:
+                pyauto_mouse.MouseActions.double_click_at(x, y)
+                logger.info(f"Double click at ({x},{y}) via PyAutoGUI")
+                return
+            except Exception as e:
+                logger.error(f"PyAutoGUI double click failed: {e}")
+        raise OperationTimeoutError("Double click failed.")
+
+
+
+
+    # right_click supports switching to PyAutoGUI
+    @staticmethod
+    def right_click(locator=None, x=None, y=None, timeout=10):
+        if locator:
+            try:
+                selenium_mouse.MouseActions.right_click(locator, timeout)
+                logger.info(f"Right click via Selenium: {locator}")
+                return
+            except Exception as e:
+                logger.warning(f"Selenium right click failed: {e}, fallback to PyAutoGUI.")
+        if x is not None and y is not None:
+            try:
+                pyauto_mouse.MouseActions.right_click_at(x, y)
+                logger.info(f"Right click at ({x},{y}) via PyAutoGUI")
+                return
+            except Exception as e:
+                logger.error(f"PyAutoGUI right click failed: {e}")
+        raise OperationTimeoutError("Right click action failed.")
+
+
+
+
+
+    @staticmethod
+    def drag_and_drop(source_locator, target_locator, timeout=10):
+        try:
+            selenium_mouse.MouseActions.drag_and_drop(source_locator, target_locator, timeout)
+        except Exception as e:
+            logger.error(f"Drag and drop from {source_locator} to {target_locator} failed: {e}")
+            raise OperationTimeoutError("Drag and drop failed.")
+
+
+
+    @staticmethod
+    def select_by_visible_text(locator, text, timeout=10):
+        try:
+            selenium_dropdown.DropdownActions.select_by_visible_text(locator, text, timeout)
+        except Exception as e:
+            logger.error(f"Select by text in {locator} failed: {e}")
+            raise OperationTimeoutError("Select by visible text failed.")
+
+
+
+
+    @staticmethod
+    def select_by_value(locator, value, timeout=10):
+        try:
+            selenium_dropdown.DropdownActions.select_by_value(locator, value, timeout)
+        except Exception as e:
+            logger.error(f"Select by value in {locator} failed: {e}")
+            raise OperationTimeoutError("Select by value failed.")
+
+
+
+
+    @staticmethod
+    def select_by_index(locator, index, timeout=10):
+        try:
+            selenium_dropdown.DropdownActions.select_by_index(locator, index, timeout)
+        except Exception as e:
+            logger.error(f"Select by index in {locator} failed: {e}")
+            raise OperationTimeoutError("Select by index failed.")
+
+
+
+
+    @staticmethod
+    def switch_to_window(window_name):
+        selenium_page.PageActions.switch_to_window(window_name)
+
+
+
+
+    @staticmethod
+    def switch_to_frame(frame_reference):
+        selenium_page.PageActions.switch_to_frame(frame_reference)
+
+
+
+
+    @staticmethod
+    def switch_to_default_content():
+        try:
+            selenium_page.PageActions.switch_to_default_content()
+        except Exception as e:
+            logger.error(f"Switch to default content failed: {e}")
+            raise OperationTimeoutError("Switch to default content failed.")
+
+
+
+
+    @staticmethod
+    def accept_alert():
+        selenium_page.PageActions.accept_alert()
+
+
+
+
+    @staticmethod
+    def dismiss_alert():
+        selenium_page.PageActions.dismiss_alert()
+
+
+
+
+    # take_screenshot supports switching to PyAutoGUI
+    @staticmethod
+    def take_screenshot(file_path):
+        try:
+            selenium_screenshot.ScreenshotActions.take_screenshot(file_path)
+            logger.info(f"Screenshot via Selenium saved to {file_path}")
+            return
+        except Exception as e:
+            logger.warning(f"Selenium screenshot failed: {e}, fallback to PyAutoGUI.")
+        try:
+            pyauto_screen.ScreenActions.take_screenshot(file_path)
+            logger.info(f"Screenshot via PyAutoGUI saved to {file_path}")
+        except Exception as e:
+            logger.error(f"PyAutoGUI screenshot failed: {e}")
+            raise OperationTimeoutError("Screenshot action failed.")
+
+
+
+
+    @staticmethod
+    def execute_script(script):
+        result = selenium_script.ScriptActions.execute_script(script)
+        return result
+
+
+
+
+    @staticmethod
+    def execute_async_script(script):
+        result = selenium_script.ScriptActions.execute_async_script(script)
+        return result
+
+
+
+
+    @staticmethod
+    def wait_for_element_visible(locator, timeout=10):
+        try:
+            selenium_wait.WaitActions.wait_for_element_visible(locator, timeout)
+            logger.info(f"Element {locator} is visible.")
+        except Exception as e:
+            logger.error(f"Wait for element {locator} visible failed: {e}")
+            raise OperationTimeoutError("Wait for element visible failed.")
+
+
+
+
+    @staticmethod
+    def wait_for_element_clickable(locator, timeout=10):
+        try:
+            selenium_wait.WaitActions.wait_for_element_clickable(locator, timeout)
+            logger.info(f"Element {locator} is clickable.")
+        except Exception as e:
+            logger.error(f"Wait for element {locator} clickable failed: {e}")
+            raise OperationTimeoutError("Wait for element clickable failed.")
+
+    
+
+
+    # Below are the functions from the PyAutogGUI:
+    # Dialog Actions:
+    @staticmethod
+    def show_alert(message):
+        pyauto_dialog.DialogActions.show_alert(message)
+
+  
+
+
+    
+    @staticmethod
+    def show_confirm(message):
+        result = pyauto_dialog.DialogActions.show_confirm(message)
+        return result
+
+    
+
+
+    @staticmethod
+    def show_prompt(message):
+        result = pyauto_dialog.DialogActions.show_prompt(message)
+        return result
+
+
+    # Keyboard Actions:
+    @staticmethod
+    def press_key(key):
+        pyauto_keyboard.KeyboardActions.press_key(key)
+
+    
+
+    @staticmethod
+    def press_hotkey(*keys):
+        pyauto_keyboard.KeyboardActions.press_hotkey(*keys)
+
+
+
+    @staticmethod
+    def hold_and_release(keys, hold_time=0.5):
+        pyauto_keyboard.KeyboardActions.hold_and_release(keys, hold_time)
+
+    
+
+    @staticmethod
+    def type_text(text, interval=0.05):
+        pyauto_keyboard.KeyboardActions.type_text(text, interval)
+
+    
+    # Mouse Actions:
+    @staticmethod
+    def move_to(x, y, duration=0.5):
+        pyauto_mouse.MouseActions.move_to(x, y, duration)
+
+
+    
+    @staticmethod
+    def drag_to(x, y, duration=0.5):
+        pyauto_mouse.MouseActions.drag_to(x, y, duration)
+
+
+
+    @staticmethod
+    def scroll(amount):
+        pyauto_mouse.MouseActions.scroll(amount)
+
+    
+
+    @staticmethod
+    def get_mouse_position():
+        pos = pyauto_mouse.MouseActions.get_position()
+        return pos
+
+
+
+    # Screen Actions:
+    @staticmethod
+    def get_pixel_color(x, y):
+        color = pyauto_screen.ScreenActions.get_pixel_color(x, y)
+        return color
+
+
+    
+    @staticmethod
+    def pixel_matches_color(x, y, expected_color):
+        match = pyauto_screen.ScreenActions.pixel_matches_color(x, y, expected_color)
+        return match
+
+
+    
+
+    @staticmethod
+    def locate_image_on_screen(image_path, confidence=0.9):
+        pos = pyauto_screen.ScreenActions.locate_image_on_screen(image_path, confidence)
+        return pos
+
+
+    
+    # Below are the functions from the PynPut:
+    @staticmethod
+    def press_key_pynput(key):
+        pynput_keyboard.KeyboardController.press_key(key)
+
+
+    
+
+    @staticmethod
+    def release_key_pynput(key):
+        pynput_keyboard.KeyboardController.release_key(key)
+
+    
+
+
+    @staticmethod
+    def press_and_hold_pynput(keys, hold_time=0.5):
+        pynput_keyboard.KeyboardController.press_and_hold(keys, hold_time)
+
+
+
+
+    @staticmethod
+    def start_keyboard_listener(on_press_func):
+        try:
+            pynput_kb_listener.KeyboardListener.start_listener(on_press_func)
+            logger.info(f"Pynput keyboard listener started.")
+        except Exception as e:
+            logger.error(f"Pynput keyboard listener failed: {e}")
+            raise OperationTimeoutError("Pynput keyboard listener failed.")
+
+
+
+
+    @staticmethod
+    def start_mouse_listener(on_click_func):
+        try:
+            pynput_mouse_listener.MouseListener.start_listener(on_click_func)
+            logger.info(f"Pynput mouse listener started.")
+        except Exception as e:
+            logger.error(f"Pynput mouse listener failed: {e}")
+            raise OperationTimeoutError("Pynput mouse listener failed.")
+
+
+    

autoflex-1.0.0/autoflex/core/config_loader.py

@@ -0,0 +1,28 @@
+import yaml
+import os
+from .logger import logger
+from .exceptions import ConfigLoadError
+
+
+
+def load_config(config_path=None):
+    """
+    Load YAML configurations, return a dict
+    """
+    default_path = os.path.join(os.path.dirname(__file__), "../config/config.yaml")
+    final_path = config_path if config_path else default_path
+    try:
+        # Check if the path exists:
+        if not os.path.exists(final_path):
+            raise FileNotFoundError(f"No Configuration File Found: {final_path}")
+
+        # Open and analyze YAML file:
+        with open(final_path, "r", encoding="utf-8") as f:
+            config = yaml.safe_load(f)
+
+        logger.info(f"Successfully Loaded The Configuration File: {final_path}")
+        return config
+
+    except Exception as e:
+        logger.error(f"Failed To Load The Configuration File: {str(e)}")
+        raise ConfigLoadError("Failed To Load Configuration File.", e)

autoflex-1.0.0/autoflex/core/exceptions.py

@@ -0,0 +1,83 @@
+
+
+class BrowserLaunchError(Exception):
+    """
+    Custom exception for browser launch failures.
+
+    Attributes:
+        message (str): Human-readable error message.
+        original_exception (Exception, optional): Original exception instance.
+    """
+
+    def __init__(self, message, original_exception=None):
+        super().__init__(message)
+        self.original_exception = original_exception
+
+
+    def __str__(self):
+        if self.original_exception:
+            return f"{self.args[0]} (Caused by: {repr(self.original_exception)})"
+        return self.args[0]
+
+
+
+class ConfigLoadError(Exception):
+    """
+    Custom exception for configuration loading failures.
+
+    Attributes:
+        message (str): Human-readable error message.
+        original_exception (Exception, optional): Original exception instance.
+    """
+
+    def __init__(self, message, original_exception=None):
+        super().__init__(message)
+        self.original_exception = original_exception
+
+    def __str__(self):
+        if self.original_exception:
+            return f"{self.args[0]} (Caused by: {repr(self.original_exception)})"
+        return self.args[0]
+
+
+
+
+
+class ElementNotFoundError(Exception):
+    """
+    Raised when a web element cannot be found.
+
+    Attributes:
+        message (str): Human-readable error message.
+        original_exception (Exception, optional): Original exception instance.
+    """
+
+    def __init__(self, message="Element Not Found", original_exception=None):
+        super().__init__(message)
+        self.original_exception = original_exception
+
+    def __str__(self):
+        if self.original_exception:
+            return f"{self.args[0]} (Caused by: {repr(self.original_exception)})"
+        return self.args[0]
+
+
+
+
+class OperationTimeoutError(Exception):
+    """
+    Raised when a wait or operation times out.
+
+    Attributes:
+        message (str): Human-readable error message.
+        original_exception (Exception, optional): Original exception instance.
+    """
+
+    def __init__(self, message="Operation Timed Out", original_exception=None):
+        super().__init__(message)
+        self.original_exception = original_exception
+
+    def __str__(self):
+        if self.original_exception:
+            return f"{self.args[0]} (Caused by: {repr(self.original_exception)})"
+        return self.args[0]

autoflex-1.0.0/autoflex/core/logger.py

@@ -0,0 +1,31 @@
+import logging
+import os
+
+
+# The path for the logger file:
+log_dir = "logs"
+os.makedirs(log_dir, exist_ok=True)
+log_file = os.path.join(log_dir, "autoflex.log")
+
+# Create a logger from logging:
+logger = logging.getLogger("AutoFlexLogger")
+logger.setLevel(logging.DEBUG)  # All levels (DEBUG -> INFO -> WARNING -> ERROR -> CRITICAL)
+
+# Log format:
+formatter = logging.Formatter(
+    "%(asctime)s - %(levelname)s - %(filename)s - %(funcName)s - %(lineno)d - %(message)s"
+)
+
+# File logger handler:
+file_handler = logging.FileHandler(log_file, encoding="utf-8")
+file_handler.setLevel(logging.DEBUG)
+file_handler.setFormatter(formatter)
+
+# Console logger handler:
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.INFO)
+console_handler.setFormatter(formatter)
+
+# Add both handlers to the logger instance:
+logger.addHandler(file_handler)
+logger.addHandler(console_handler)

autoflex-1.0.0/autoflex/core/web_manager.py

@@ -0,0 +1,115 @@
+# Imports
+from selenium import webdriver
+from selenium.webdriver.chrome.service import Service as ChromeService
+from selenium.webdriver.edge.service import Service as EdgeService
+from selenium.webdriver.firefox.service import Service as FirefoxService
+
+from selenium.webdriver.chrome.options import Options as ChromeOptions
+from selenium.webdriver.edge.options import Options as EdgeOptions
+from selenium.webdriver.firefox.options import Options as FirefoxOptions
+
+from .logger import logger
+from .exceptions import BrowserLaunchError
+from .config_loader import load_config
+
+
+# The Browser Manager class:
+class Browser:
+    _driver = None  # Class variable (private)
+
+
+
+    @classmethod
+    def start(cls, browser_type="chrome", remote_url=None, config_path=None):   # The config_path here is for user's customizable path
+        try:
+            logger.info(f"Starting The Browser: {browser_type}")
+
+            config = load_config(config_path)
+            options = None   # Initialize the options and service, will update later
+            service = None
+
+            # Chrome logic:
+            if browser_type.lower() == "chrome":
+                options = ChromeOptions()
+                driver_path = config.get("chrome")
+                if not driver_path:
+                    raise FileNotFoundError("Chrome Driver Path Not Specified In config.yaml")
+                service = ChromeService(executable_path=driver_path)
+
+                for arg in config.get("chrome_args", []):
+                    options.add_argument(arg)
+
+            # Edge logic:
+            elif browser_type.lower() == "edge":
+                options = EdgeOptions()
+                driver_path = config.get("edge")
+                if not driver_path:
+                    raise FileNotFoundError("Edge Driver Path Not Specified In config.yaml")
+                service = EdgeService(executable_path=driver_path)
+
+                for arg in config.get("edge_args", []):
+                    options.add_argument(arg)
+
+            # Firefox logic:
+            elif browser_type.lower() == "firefox":
+                options = FirefoxOptions()
+                driver_path = config.get("firefox")
+                if not driver_path:
+                    raise FileNotFoundError("Firefox Driver Path Not Specified In config.yaml")
+                service = FirefoxService(executable_path=driver_path)
+
+
+                for key, value in config.get("firefox_prefs", {}).items():
+                    options.set_preference(key, value)
+
+            else:
+                raise ValueError(f"Not Supported Browser Type: {browser_type}")
+
+            # Logic of dealing with remote url:
+            if remote_url:
+                logger.info(f"Utilizing Remote WebDriver: {remote_url}")
+                cls._driver = webdriver.Remote(command_executor=remote_url, options=options)
+            else:
+                if browser_type.lower() == "chrome":
+                    cls._driver = webdriver.Chrome(service=service, options=options)
+                elif browser_type.lower() == "edge":
+                    cls._driver = webdriver.Edge(service=service, options=options)
+                elif browser_type.lower() == "firefox":
+                    cls._driver = webdriver.Firefox(service=service, options=options)
+
+                cls._driver.maximize_window()
+
+            logger.info(f"{browser_type} Successfully Running")
+            return cls._driver
+
+        except Exception as e:
+            logger.error(f"Error Occured When Trying To Start The Browser: {str(e)}")
+            raise BrowserLaunchError(f"Failed To Start The Browser: {str(e)}")
+
+
+
+
+    '''
+    This method acts as a getter, 
+    it returns the current driver object
+    '''
+    @classmethod
+    def get_driver(cls):
+        if cls._driver is None:
+            raise BrowserLaunchError("Not Starting The Browser Yet, Please call Browser.start()")
+        return cls._driver
+
+
+
+
+    @classmethod
+    def quit(cls):
+        try:
+            if cls._driver:
+                logger.info("Closing the browser")
+                cls._driver.quit()
+                cls._driver = None
+        except Exception as e:
+            logger.error(f"Failed to close the browser: {str(e)}")
+
+

autoflex-1.0.0/autoflex/tests/test_browser.py

@@ -0,0 +1,50 @@
+from autoflex.core.web_manager import Browser
+from autoflex.core.actions import Actions
+from autoflex.core.exceptions import BrowserLaunchError
+import time
+
+
+def on_key_press(key):
+    print(f"[监听] 键盘按下: {key}")
+    if str(key) == "'q'":
+        print("监听到 Q，停止监听")
+        return False
+
+
+def on_mouse_click(x, y, button, pressed):
+    if pressed:
+        print(f"[监听] 鼠标点击: ({x},{y}) {button}")
+
+
+try:
+    # 启动浏览器
+    driver = Browser.start("edge")
+    Actions.take_screenshot("startup.png")
+
+    # 打开百度并执行点击+输入+截图
+    driver.get("https://www.baidu.com")
+    Actions.take_screenshot("baidu_home.png")
+    Actions.click(locator=("css selector", "#kw"))
+    Actions.type_text("AutoFlex 调度器测试")
+    Actions.click(locator=("css selector", "#su"))
+
+    # 鼠标移动+截图
+    Actions.move_to(500, 200)
+    Actions.take_screenshot("after_move.png")
+
+    # 执行 Pynput 键盘监听
+    print("按 Q 键停止键盘监听：")
+    Actions.start_keyboard_listener(on_key_press)
+
+    # 执行 Pynput 鼠标监听
+    print("鼠标点击事件监听中，单击停止监听：")
+    Actions.start_mouse_listener(on_mouse_click)
+
+    input("测试完成，按 Enter 退出")
+    Browser.quit()
+
+except BrowserLaunchError as e:
+    print(f"Failed to launch browser: {e}")
+except Exception as e:
+    print(f"执行异常: {e}")
+

autoflex-1.0.0/autoflex.egg-info/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: autoflex
+Version: 1.0.0
+Summary: Web and System Automation Testing Framework
+Home-page: https://github.com/LZYEIL/AutoFlex
+Author: Zhiyuan Li
+Author-email: zhiyuanjeremy@gmail.com
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: selenium>=4.24.0
+Requires-Dist: pyautogui>=0.9.54
+Requires-Dist: pynput>=1.8.1
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# This is AutoFlex README Template

autoflex-1.0.0/autoflex.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+pyproject.toml
+setup.py
+autoflex/__init__.py
+autoflex.egg-info/PKG-INFO
+autoflex.egg-info/SOURCES.txt
+autoflex.egg-info/dependency_links.txt
+autoflex.egg-info/requires.txt
+autoflex.egg-info/top_level.txt
+autoflex/core/__init__.py
+autoflex/core/actions.py
+autoflex/core/config_loader.py
+autoflex/core/exceptions.py
+autoflex/core/logger.py
+autoflex/core/web_manager.py
+autoflex/tests/__init__.py
+autoflex/tests/test_browser.py

autoflex-1.0.0/autoflex.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

autoflex-1.0.0/autoflex.egg-info/requires.txt

@@ -0,0 +1,3 @@
+selenium>=4.24.0
+pyautogui>=0.9.54
+pynput>=1.8.1

autoflex-1.0.0/autoflex.egg-info/top_level.txt

@@ -0,0 +1 @@
+autoflex

autoflex-1.0.0/pyproject.toml

@@ -0,0 +1,3 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"

autoflex-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

autoflex-1.0.0/setup.py

@@ -0,0 +1,24 @@
+from setuptools import setup, find_packages
+
+setup(
+    name='autoflex',                
+    version='1.0.0',
+    description='Web and System Automation Testing Framework',
+    long_description=open('README.md', encoding='utf-8').read(),
+    long_description_content_type='text/markdown',
+    author='Zhiyuan Li',
+    author_email='zhiyuanjeremy@gmail.com',
+    url='https://github.com/LZYEIL/AutoFlex',
+    packages=find_packages(),       
+    install_requires=[              
+        'selenium>=4.24.0',
+        'pyautogui>=0.9.54',
+        'pynput>=1.8.1',
+    ],
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+    python_requires='>=3.8',
+)