pyautoscene 0.2.1__tar.gz → 0.2.3__tar.gz

{pyautoscene-0.2.1 → pyautoscene-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyautoscene
-Version: 0.2.1
+Version: 0.2.3
 Summary: Advance GUI automation
 Author-email: pritam-dey3 <pritam.pritamdey.984@gmail.com>
 License-File: LICENSE

pyautoscene-0.2.3/examples/saucedemo/main.py

@@ -0,0 +1,75 @@
+import pyautogui as gui
+
+from pyautoscene import ImageElement, Scene, Session, TextElement
+
+# Define all elements separately
+add_to_cart = ImageElement("examples/saucedemo/references/add_to_cart_button.png")
+username = ImageElement("examples/saucedemo/references/username.png")
+backpack = TextElement(
+    "Sauce Labs Bike Light", region="x:2/2 y:(2-4)/5", case_sensitive=False
+)
+cart_icon = ImageElement("examples/saucedemo/references/cart_icon.png")
+checkout_button = ImageElement("examples/saucedemo/references/checkout_button.png")
+
+login = Scene(
+    "Login",
+    elements=[
+        TextElement("Username", region="x:2/3 y:(1-2)/3"),
+        TextElement("Password", region="x:2/3 y:(1-2)/3"),
+        # ReferenceImage("examples/saucedemo/references/login_button.png"),
+    ],
+    initial=True,
+)
+
+dashboard = Scene(
+    "Dashboard",
+    elements=[
+        TextElement("Swag Labs", region="x:2/3 y:1/3"),
+        TextElement("Products", region="x:1/3 y:1/3"),
+    ],
+)
+
+cart = Scene(
+    "Cart", elements=[TextElement("Your Cart", region="x:1/3 y:1/3"), cart_icon]
+)
+
+
+@login.action(transitions_to=dashboard)
+def perform_login(username_inp: str, password_inp: str):
+    """Performs the login action to transition from Login to Dashboard."""
+    username.locate_and_click()
+    gui.write(username_inp, interval=0.1)
+    gui.press("tab")
+    gui.write(password_inp, interval=0.1)
+    gui.press("enter")
+
+
+@dashboard.action()
+def add_products_to_cart(target: str):
+    """Adds products to the cart."""
+    if target == "backpack":
+        backpack.locate_and_click()
+    else:
+        backpack.locate_and_click()
+    add_to_cart.locate_and_click(region="x:2/3 y:(2-3)/3", clicks=1)
+
+
+@dashboard.action(transitions_to=cart)
+def view_cart():
+    """Views the cart."""
+    cart_icon.locate_and_click()
+
+
+@cart.action()
+def checkout():
+    """Checks out the items in the cart."""
+    checkout_button.locate_and_click()
+
+
+session = Session(scenes=[login, dashboard, cart])
+
+gui.hotkey("alt", "tab")
+session.expect(dashboard, username_inp="standard_user", password_inp="secret_sauce")
+session.invoke("add_products_to_cart", target="backpack")
+session.invoke("view_cart")
+session.invoke("checkout")

pyautoscene-0.2.3/experimental/README.md

@@ -0,0 +1,2 @@
+# Experimental Algorithms
+This directory contains experimental algorithms and features that are not yet part of the main library.

pyautoscene-0.2.3/experimental/__init__.py

@@ -0,0 +1,3 @@
+from .algorithms.ilish import ilish
+
+__all__ = ["ilish"]

pyautoscene-0.2.3/experimental/algorithms/ilish.py

@@ -0,0 +1,88 @@
+from typing import Literal
+
+import cv2
+import numpy as np
+from PIL import Image
+
+from pyautoscene.region import Region
+
+type OpenCvTransformKernel = Literal["CROSS", "RECT", "ELLIPSE"]
+type OpenCvTransformMorphology = Literal[
+    "ERODE", "DILATE", "OPEN", "CLOSE", "GRADIENT", "TOPHAT", "BLACKHAT", "HITMISS"
+]
+type OpenCvThresholdAlgo = Literal[
+    "BINARY",
+    "BINARY_INV",
+    "TRUNC",
+    "TOZERO",
+    "TOZERO_INV",
+    "MASK",
+    "OTSU",
+    "TRIANGLE",
+    "DRYRUN",
+]
+type OpenCvMatchAlgo = Literal[
+    "SQDIFF", "SQDIFF_NORMED", "CCORR", "CCORR_NORMED", "CCOEFF", "CCOEFF_NORMED"
+]
+
+
+def ilish(
+    needle: Image.Image,
+    haystack: Image.Image,
+    *,
+    transform_kernel: OpenCvTransformKernel = "ELLIPSE",
+    transform_shape: tuple[int, int] = (53, 53),
+    transform_morphology: OpenCvTransformMorphology = "BLACKHAT",
+    threshold: int = 127,
+    threshold_max_value: int = 255,
+    threshold_algo: OpenCvThresholdAlgo = "BINARY_INV",
+    match_algo: OpenCvMatchAlgo = "SQDIFF",
+    match_mask_value: int | None = 255,
+    confidence: float = 0.9,
+):
+    def transform(inp: Image.Image) -> np.ndarray:
+        gray = cv2.cvtColor(np.array(inp.convert("RGB")), cv2.COLOR_RGB2GRAY)
+        kernel = cv2.getStructuringElement(
+            getattr(cv2, f"MORPH_{transform_kernel}"), transform_shape
+        )
+        blackhat = cv2.morphologyEx(
+            gray, getattr(cv2, f"MORPH_{transform_morphology}"), kernel
+        )
+        thresh = cv2.threshold(
+            blackhat,
+            threshold,
+            threshold_max_value,
+            getattr(cv2, f"THRESH_{threshold_algo}"),
+        )[1]
+        return thresh
+
+    if haystack.size[0] < needle.size[0] or haystack.size[1] < needle.size[1]:
+        raise ValueError(
+            "needle dimension(s) exceed the haystack image or region dimensions"
+        )
+
+    needle_t = transform(needle)
+    haystack_t = transform(haystack)
+    result = cv2.matchTemplate(
+        haystack_t,
+        needle_t,
+        getattr(cv2, f"TM_{match_algo}"),
+        None,
+        (needle_t != match_mask_value).astype(np.uint8)
+        if match_mask_value is not None
+        else None,
+    )
+
+    if match_algo.startswith("SQDIFF"):
+        match_filter = result < confidence
+    else:
+        match_filter = result > confidence
+
+    match_indices = np.arange(result.size)[match_filter.flatten()]
+    matches = np.unravel_index(match_indices, result.shape)
+
+    match_regions = [
+        Region(x, y, needle.width, needle.height)
+        for x, y in zip(matches[1], matches[0])
+    ]
+    return (match_regions, result, needle_t, haystack_t)

{pyautoscene-0.2.1 → pyautoscene-0.2.3}/pyproject.toml

@@ -13,7 +13,7 @@ description = "Advance GUI automation"
 name = "pyautoscene"
 readme = "README.md"
 requires-python = ">=3.13"
-version = "0.2.1"
+version = "0.2.3"
 
 [project.scripts]
 pyautoscene = "pyautoscene:main"
@@ -39,3 +39,10 @@ ocr = [
 
 [tool.poe.tasks]
 precmt = "pre-commit run --all-files"
+
+[tool.ruff.format]
+skip-magic-trailing-comma = true
+
+[tool.ruff]
+ignore = ["E731"]
+line-length = 88

pyautoscene-0.2.3/src/pyautoscene/__init__.py

@@ -0,0 +1,6 @@
+from .references import ImageElement, TextElement
+from .region import Region, RegionSpec
+from .scene import Scene
+from .session import Session
+
+__all__ = ["Scene", "Session", "ImageElement", "TextElement", "RegionSpec", "Region"]

pyautoscene-0.2.3/src/pyautoscene/_types.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+from typing import Literal
+
+type MouseButton = Literal["left", "right"]
+type TowardsDirection = Literal["top", "left", "bottom", "right", None]

pyautoscene-0.2.3/src/pyautoscene/constants.py

@@ -0,0 +1,6 @@
+import os
+
+LOCATE_AND_CLICK_DELAY = float(os.getenv("PYAUTOSCENE_LOCATE_AND_CLICK_DELAY", 0.3))
+
+# pixels per second, used for calculating move duration
+POINTER_SPEED = int(os.getenv("PYAUTOSCENE_POINTER_SPEED", 1000))

{pyautoscene-0.2.1 → pyautoscene-0.2.3}/src/pyautoscene/ocr.py

@@ -1,11 +1,12 @@
 import logging
+import os
 from hashlib import sha256
 from pathlib import Path
 
 import numpy as np
 from PIL import Image
 
-from .screen import Region
+from .region import Region
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
@@ -18,7 +19,9 @@ except ImportError:
         "RapidOCR is not installed. Please install it using 'pip install pyautoscene[ocr]'."
     )
 
-ocr_config_path = Path(__file__).parent / "ocr_config.yaml"
+default_ocr_config_path = Path(__file__).parent / "ocr_config.yaml"
+ocr_config_path = Path(os.getenv("PYAUTOSCENE_OCR_CONFIG", default_ocr_config_path))
+logger.info(f"OCR config path: {ocr_config_path}")
 
 
 def hash_image(img: Image.Image) -> str:

{pyautoscene-0.2.1 → pyautoscene-0.2.3}/src/pyautoscene/references.py

@@ -1,19 +1,41 @@
 from abc import ABC, abstractmethod
-from typing import override
+from typing import Callable, override
 
 import pyautogui as gui
+from PIL import Image
 
-from .screen import RegionSpec, generate_region_from_spec, locate_on_screen
+from ._types import MouseButton, TowardsDirection
+from .region import Region, RegionSpec
+from .utils import locate_on_screen, move_and_click
 
 
 class ReferenceElement(ABC):
     """Base class for reference elements used to identify scenes."""
 
     @abstractmethod
-    def is_visible(self, region: RegionSpec | None = None) -> RegionSpec | None:
+    def locate(self, region: RegionSpec | None = None) -> Region | None:
         """Detect the presence of the reference element."""
         raise NotImplementedError("Subclasses must implement this method")
 
+    def locate_and_click(
+        self,
+        offset: tuple[int, int] = (0, 0),
+        region: RegionSpec | None = None,
+        clicks: int = 1,
+        button: MouseButton = "left",
+        towards: TowardsDirection = None,
+    ):
+        """Locate the reference element and click on it."""
+        region = self.locate(region=region)
+        assert region is not None, f"Element {self} not found on screen"
+        move_and_click(
+            target_region=region,
+            clicks=clicks,
+            button=button,
+            offset=offset,
+            towards=towards,
+        )
+
 
 class ImageElement(ReferenceElement):
     """Reference element that identifies a scene by an image."""
@@ -23,13 +45,15 @@ class ImageElement(ReferenceElement):
         path: str | list[str],
         confidence: float = 0.999,
         region: RegionSpec | None = None,
+        locator: Callable[[Image.Image, Image.Image], list[Region]] | None = None,
     ):
         self.path = path
         self.confidence = confidence
         self.region = region
+        self.locator = locator
 
     @override
-    def is_visible(self, region: RegionSpec | None = None):
+    def locate(self, region: RegionSpec | None = None) -> Region | None:
         """Method to detect the presence of the image in the current screen."""
         if isinstance(self.path, str):
             path = [self.path]  # Ensure path is a list for consistency
@@ -38,7 +62,10 @@ class ImageElement(ReferenceElement):
         for image_path in path:
             try:
                 location = locate_on_screen(
-                    image_path, region=region or self.region, confidence=self.confidence
+                    image_path,
+                    region=region if region else self.region,
+                    confidence=self.confidence,
+                    locator=self.locator,
                 )
                 return location
             except gui.ImageNotFoundException:
@@ -49,10 +76,7 @@ class TextElement(ReferenceElement):
     """Reference element that identifies a scene by text."""
 
     def __init__(
-        self,
-        text: str,
-        region: RegionSpec | None = None,
-        case_sensitive: bool = False,
+        self, text: str, region: RegionSpec | None = None, case_sensitive: bool = False
     ):
         self.text = text
         self.region = region
@@ -60,19 +84,17 @@ class TextElement(ReferenceElement):
         if not case_sensitive:
             self.text = self.text.lower()
 
-    def is_visible(self, region: RegionSpec | None = None):
+    def locate(self, region: RegionSpec | None = None):
         """Method to detect the presence of the text in the current screen."""
         from .ocr import OCR
 
         ocr = OCR()
         region = region or self.region
         for text, detected_region in ocr.recognize_text(
-            gui.screenshot(
-                region=generate_region_from_spec(region).to_box() if region else None
-            )
+            gui.screenshot(region=Region.from_spec(region).to_box() if region else None)
         ):
             if not self.case_sensitive:
                 text = text.lower()
             if text.strip() == self.text.strip():
-                return detected_region
+                return detected_region.resolve(base=region)
         return None

pyautoscene-0.2.3/src/pyautoscene/region.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+import numpy as np
+import pyautogui as gui
+from pyscreeze import Box
+
+type RegionSpec = Region | str
+
+axis_pattern = re.compile(r"(?P<d>[xy]):\(?(?P<i>\d+)(?:-(?P<j>\d+))?\)?/(?P<n>\d+)")
+
+
+@dataclass(frozen=True, slots=True)
+class Region:
+    left: int
+    top: int
+    width: int
+    height: int
+
+    def to_box(self) -> Box:
+        """Convert to a pyscreeze Box."""
+        return Box(self.left, self.top, self.width, self.height)
+
+    @classmethod
+    def from_box(cls, box: Box) -> Region:
+        """Create a Region from a pyscreeze Box."""
+        return cls(left=box.left, top=box.top, width=box.width, height=box.height)
+
+    @property
+    def center(self) -> tuple[int, int]:
+        """Get the center coordinates of the region."""
+        return (self.left + self.width // 2, self.top + self.height // 2)
+
+    @classmethod
+    def from_spec(
+        cls, spec: RegionSpec, shape: tuple[int, int] | None = None
+    ) -> Region:
+        if isinstance(spec, Region):
+            return spec
+        if shape is None:
+            img = np.array(gui.screenshot())
+            shape = (img.shape[0]), (img.shape[1])
+
+        default_region = {"left": 0, "top": 0, "width": shape[1], "height": shape[0]}
+
+        axis_mapping = {"x": ("left", "width", 1), "y": ("top", "height", 0)}
+        for axis, i, j, n in axis_pattern.findall(spec):
+            alignment, size_attr, dim_index = axis_mapping[axis]
+            size = shape[dim_index] // int(n)
+            i, j = int(i), int(j) if j else int(i)
+            default_region.update({
+                alignment: (i - 1) * size,
+                size_attr: (j - i + 1) * size,
+            })
+
+        return cls(**default_region)
+
+    def resolve(self, base: RegionSpec | None) -> Region:
+        if base is None:
+            return self
+        if isinstance(base, str):
+            base = Region.from_spec(base)
+        return Region(
+            left=self.left + base.left,
+            top=self.top + base.top,
+            width=self.width,
+            height=self.height,
+        )

{pyautoscene-0.2.1 → pyautoscene-0.2.3}/src/pyautoscene/scene.py

@@ -7,7 +7,7 @@ from statemachine import State
 from pyautoscene.utils import is_valid_variable_name
 
 from .references import ReferenceElement
-from .screen import Region
+from .region import Region
 
 
 class ActionInfo(TypedDict):
@@ -55,7 +55,7 @@ class Scene(State):
         """Check if any reference element is currently on screen."""
         # TODO: Refactor after text recognition is implemented
         # elements = (elem for elem in self.elements if isinstance(elem, ReferenceImage))
-        return all(elem.is_visible(region) for elem in self.elements)
+        return all(elem.locate(region) for elem in self.elements)
 
     def __repr__(self):
         return f"Scene({self.name!r}, elements={len(self.elements)})"

{pyautoscene-0.2.1 → pyautoscene-0.2.3}/src/pyautoscene/session.py

@@ -1,15 +1,18 @@
 from __future__ import annotations
 
+import time
 from typing import Callable
 
 import networkx as nx
+from PIL import Image
 from statemachine import State, StateMachine
 from statemachine.factory import StateMachineMetaclass
 from statemachine.states import States
 from statemachine.transition_list import TransitionList
 
+from .references import ImageElement, ReferenceElement
+from .region import Region
 from .scene import Scene
-from .screen import Region
 
 
 class SceneRecognitionError(Exception):
@@ -61,9 +64,18 @@ def get_current_scene(scenes: list[Scene], region: Region | None = None) -> Scen
 class Session:
     """A session manages the state machine for GUI automation scenes."""
 
-    def __init__(self, scenes: list[Scene]):
+    def __init__(
+        self,
+        scenes: list[Scene],
+        image_locator: Callable[[Image.Image, Image.Image], list[Region]] | None = None,
+    ):
         self._scenes_list = scenes
         self._scenes_dict = {scene.name: scene for scene in scenes}
+        self.image_locator = image_locator
+        for scene in self._scenes_list:
+            for elem in scene.elements:
+                if isinstance(elem, ImageElement):
+                    elem.locator = image_locator
 
         # Create dynamic StateMachine class and instantiate it
         self._sm, self.transitions, self.leaf_actions = build_dynamic_state_machine(
@@ -84,9 +96,7 @@ class Session:
         present_scene = get_current_scene(self._scenes_list)
         all_paths = list(
             nx.all_simple_paths(
-                self.graph,
-                source=present_scene.name,
-                target=target_scene.name,
+                self.graph, source=present_scene.name, target=target_scene.name
             )
         )
         if len(all_paths) == 0:
@@ -132,6 +142,19 @@ class Session:
             f"Action '{action_name}' not found in current scene '{self.current_scene.name}'"
         )
 
+    def wait_until(self, target: Scene | ReferenceElement, interval: float = 1):
+        """Wait until the target scene or reference element is on screen."""
+        found = False
+        while not found:
+            if isinstance(target, Scene):
+                found = target.is_on_screen()
+            elif isinstance(target, ReferenceElement):
+                found = target.locate() is not None
+            else:
+                raise TypeError("Target must be a Scene or ReferenceElement.")
+            if not found:
+                time.sleep(interval)
+
     def __repr__(self):
         current = self.current_scene
         current_name = current.name if current else "None"

pyautoscene-0.2.3/src/pyautoscene/utils.py

@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+import logging
+import os
+import time
+from keyword import iskeyword
+from typing import Callable, overload
+
+import numpy as np
+import pyautogui as gui
+from PIL import Image
+
+from ._types import MouseButton, TowardsDirection
+from .constants import LOCATE_AND_CLICK_DELAY, POINTER_SPEED
+from .region import Region, RegionSpec
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def locate_and_click(
+    reference: Image.Image | str,
+    clicks: int = 1,
+    button: MouseButton = "left",
+    region: RegionSpec | None = None,
+    confidence: float = 0.999,
+    grayscale: bool = True,
+    limit: int = 1,
+    offset: tuple[int, int] = (0, 0),
+    towards: TowardsDirection | None = None,
+):
+    time.sleep(LOCATE_AND_CLICK_DELAY)
+    found_region = locate_on_screen(
+        reference,
+        region=region,
+        confidence=confidence,
+        grayscale=grayscale,
+        limit=limit,
+    )
+    assert found_region is not None, f"Could not locate {reference} on screen."
+    move_and_click(
+        found_region, clicks=clicks, button=button, offset=offset, towards=towards
+    )
+    time.sleep(LOCATE_AND_CLICK_DELAY)
+
+
+def move_and_click(
+    target_region: RegionSpec,
+    clicks: int = 1,
+    button: MouseButton = "left",
+    offset: tuple[int, int] = (0, 0),
+    towards: TowardsDirection | None = None,
+):
+    """Move to the center or edge of the region and click.
+
+    The offset is always added to the calculated target point.
+    For example, for 'bottom', offset=(0, 5) means 5 pixels below the bottom edge.
+    """
+    _target_region = Region.from_spec(target_region)
+    base_points = {
+        "top": (_target_region.center[0], _target_region.top),
+        "left": (_target_region.left, _target_region.center[1]),
+        "bottom": (
+            _target_region.center[0],
+            _target_region.top + _target_region.height - 1,
+        ),
+        "right": (
+            _target_region.left + _target_region.width - 1,
+            _target_region.center[1],
+        ),
+        None: _target_region.center,
+    }
+    if towards not in base_points:
+        raise ValueError(f"Invalid direction: {towards}")
+    base = base_points[towards]
+    target = (base[0] + offset[0], base[1] + offset[1])
+
+    current = gui.position()
+    duration = np.linalg.norm(np.array(target) - np.array(current)) / POINTER_SPEED
+    gui.moveTo(*target, float(duration), gui.easeInOutQuad)  # type: ignore
+    gui.click(clicks=clicks, button=button)
+
+
+def is_valid_variable_name(name):
+    return name.isidentifier() and not iskeyword(name)
+
+
+@overload
+def locate_on_screen(
+    reference: Image.Image | str,
+    region: RegionSpec | None = None,
+    confidence: float = 0.999,
+    grayscale: bool = True,
+    limit: int = 1,
+    locator: Callable[[Image.Image, Image.Image], list[Region]] | None = None,
+) -> Region | None: ...
+@overload
+def locate_on_screen(
+    reference: Image.Image | str,
+    region: RegionSpec | None = None,
+    confidence: float = 0.999,
+    grayscale: bool = True,
+    limit: int = 1,
+    locator: Callable[[Image.Image, Image.Image], list[Region]] | None = None,
+) -> list[Region] | None: ...
+def locate_on_screen(
+    reference: Image.Image | str,
+    region: RegionSpec | None = None,
+    confidence: float = 0.999,
+    grayscale: bool = True,
+    limit: int = 1,
+    locator: Callable[[Image.Image, Image.Image], list[Region]] | None = None,
+):
+    """Locate a region on the screen."""
+    if isinstance(reference, str):
+        if not os.path.exists(reference):
+            raise FileNotFoundError(f"Image file {reference} does not exist.")
+        reference = Image.open(reference)
+    if locator is None:
+        try:
+            location = gui.locateOnScreen(
+                reference,
+                region=Region.from_spec(region).to_box() if region else None,
+                grayscale=grayscale,
+                confidence=confidence,
+                limit=limit,
+            )
+            if location:
+                return Region.from_box(location)
+        except gui.ImageNotFoundException:
+            return None
+        except FileNotFoundError:
+            return None
+    else:
+        screenshot = gui.screenshot(
+            region=Region.from_spec(region).to_box() if region else None
+        )
+        logger.info(
+            f"Searching in region: {Region.from_spec(region).to_box() if region else None}.\nGiven region: {region}"
+        )
+        detections = locator(reference, screenshot)
+        logger.info("total detections: %d", len(detections))
+        if len(detections) == 0:
+            return None
+        elif limit > 1:
+            return [det.resolve(region) for det in detections[:limit]]
+        else:
+            return detections[0].resolve(region)

{pyautoscene-0.2.1 → pyautoscene-0.2.3}/uv.lock

@@ -398,7 +398,7 @@ sdist = { url = "https://files.pythonhosted.org/packages/65/ff/cdae0a8c2118a0de7
 
 [[package]]
 name = "pyautoscene"
-version = "0.2.1"
+version = "0.2.3"
 source = { editable = "." }
 dependencies = [
     { name = "networkx" },

pyautoscene-0.2.1/examples/saucedemo/main.py

@@ -1,68 +0,0 @@
-import pyautogui as gui
-
-from pyautoscene import ImageElement, Scene, Session, TextElement
-from pyautoscene.utils import locate_and_click
-
-login = Scene(
-    "Login",
-    elements=[
-        TextElement("Username", region="x-1/3 y-(1-2)/3"),
-        TextElement("Password", region="x-1/3 y-(2-3)/3"),
-        # ReferenceImage("examples/saucedemo/references/login_button.png"),
-    ],
-    initial=True,
-)
-
-dashboard = Scene(
-    "Dashboard",
-    elements=[
-        TextElement("Swag Labs", region="x-2/3 y-1/3"),
-        TextElement("Products", region="x-1/3 y-1/3"),
-    ],
-)
-
-cart = Scene(
-    "Cart",
-    elements=[
-        TextElement("Your Cart", region="x-1/3 y-1/3"),
-        ImageElement("examples/saucedemo/references/cart_icon.png"),
-    ],
-)
-
-
-@login.action(transitions_to=dashboard)
-def perform_login(username: str, password: str):
-    """Performs the login action to transition from Login to Dashboard."""
-    locate_and_click("examples/saucedemo/references/username.png")
-    gui.write(username, interval=0.1)
-    gui.press("tab")
-    gui.write(password, interval=0.1)
-    gui.press("enter")
-
-
-@dashboard.action()
-def add_products_to_cart(target: str):
-    """Adds products to the cart."""
-    locate_and_click(f"examples/saucedemo/references/{target}.png")
-    locate_and_click("examples/saucedemo/references/add_to_cart_button.png")
-
-
-@dashboard.action(transitions_to=cart)
-def view_cart():
-    """Views the cart."""
-    locate_and_click("examples/saucedemo/references/cart_icon.png")
-
-
-@cart.action()
-def checkout():
-    """Checks out the items in the cart."""
-    locate_and_click("examples/saucedemo/references/checkout_button.png")
-
-
-session = Session(scenes=[login, dashboard, cart])
-
-gui.hotkey("alt", "tab")
-session.expect(dashboard, username="standard_user", password="secret_sauce")
-session.invoke("add_products_to_cart", target="backpack")
-session.invoke("view_cart")
-session.invoke("checkout")

pyautoscene-0.2.1/src/pyautoscene/__init__.py

@@ -1,5 +0,0 @@
-from .references import ImageElement, TextElement
-from .scene import Scene
-from .session import Session
-
-__all__ = ["Scene", "Session", "ImageElement", "TextElement"]

pyautoscene-0.2.1/src/pyautoscene/screen.py

@@ -1,79 +0,0 @@
-from __future__ import annotations
-
-import re
-from dataclasses import dataclass
-
-import numpy as np
-import pyautogui as gui
-from PIL import Image
-from pyscreeze import Box
-
-axis_pattern = re.compile(r"(?P<d>[xy]):\(?(?P<i>\d+)(?:-(?P<j>\d+))?\)?/(?P<n>\d+)")
-
-
-@dataclass(frozen=True, slots=True)
-class Region:
-    left: int
-    top: int
-    width: int
-    height: int
-
-    def to_box(self) -> Box:
-        """Convert to a pyscreeze Box."""
-        return Box(self.left, self.top, self.width, self.height)
-
-    @classmethod
-    def from_box(cls, box: Box) -> Region:
-        """Create a Region from a pyscreeze Box."""
-        return cls(left=box.left, top=box.top, width=box.width, height=box.height)
-
-
-RegionSpec = Region | str
-
-
-def generate_region_from_spec(
-    spec: RegionSpec, shape: tuple[int, int] | None = None
-) -> Region:
-    if isinstance(spec, Region):
-        return spec
-    if shape is None:
-        img = np.array(gui.screenshot())
-        shape = (img.shape[0]), (img.shape[1])
-
-    default_region = {"left": 0, "top": 0, "width": shape[1], "height": shape[0]}
-
-    axis_mapping = {"x": ("left", "width", 1), "y": ("top", "height", 0)}
-    for axis, i, j, n in axis_pattern.findall(spec):
-        alignment, size_attr, dim_index = axis_mapping[axis]
-        size = shape[dim_index] // int(n)
-        i, j = int(i), int(j) if j else int(i)
-        default_region.update({
-            alignment: (i - 1) * size,
-            size_attr: (j - i + 1) * size,
-        })
-
-    return Region(**default_region)
-
-
-def locate_on_screen(
-    reference: Image.Image | str,
-    region: RegionSpec | None = None,
-    confidence: float = 0.999,
-    grayscale: bool = True,
-    limit: int = 1,
-) -> Region | None:
-    """Locate a region on the screen."""
-    try:
-        location = gui.locateOnScreen(
-            reference,
-            region=generate_region_from_spec(region).to_box() if region else None,
-            grayscale=grayscale,
-            confidence=confidence,
-            limit=limit,
-        )
-        if location:
-            return Region.from_box(location)
-    except gui.ImageNotFoundException:
-        return None
-    except FileNotFoundError:
-        return None

pyautoscene-0.2.1/src/pyautoscene/utils.py

@@ -1,25 +0,0 @@
-from __future__ import annotations
-
-import time
-from keyword import iskeyword
-from typing import Literal
-
-import pyautogui as gui
-
-LOCATE_AND_CLICK_DELAY = 0.2
-
-
-def locate_and_click(
-    filename: str, clicks: int = 1, button: Literal["left", "right"] = "left"
-):
-    time.sleep(LOCATE_AND_CLICK_DELAY)
-    locate = gui.locateOnScreen(filename, grayscale=True)
-    assert locate is not None, f"Could not locate {filename} on screen."
-    locate_center = (locate.left + locate.width // 2), (locate.top + locate.height // 2)
-    gui.moveTo(*locate_center, 0.6, gui.easeInOutQuad)  # type: ignore
-    gui.click(clicks=clicks, button=button)
-    time.sleep(LOCATE_AND_CLICK_DELAY)
-
-
-def is_valid_variable_name(name):
-    return name.isidentifier() and not iskeyword(name)