pyautoscene 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

pyautoscene/screen.py

@@ -1,79 +1,79 @@
-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
+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/session.py

@@ -1,140 +1,140 @@
-from __future__ import annotations
-
-from typing import Callable
-
-import networkx as nx
-from statemachine import State, StateMachine
-from statemachine.factory import StateMachineMetaclass
-from statemachine.states import States
-from statemachine.transition_list import TransitionList
-
-from .scene import Scene
-from .screen import Region
-
-
-class SceneRecognitionError(Exception):
-    pass
-
-
-def build_dynamic_state_machine(
-    scenes: list[Scene],
-) -> tuple[StateMachine, dict[str, TransitionList], dict[str, Callable]]:
-    """Create a dynamic StateMachine class from scenes using StateMachineMetaclass."""
-
-    states = {scene.name: scene for scene in scenes}
-    transitions = {}
-    leaf_actions = {}
-    for scene in scenes:
-        for action_name, action_info in scene.actions.items():
-            target_scene = action_info["transitions_to"]
-            if target_scene is not None:
-                event_name = f"event_{action_name}"
-                new_transition = scene.to(target_scene, event=event_name)
-                new_transition.on(action_info["action"])
-                transitions[event_name] = new_transition
-            else:
-                leaf_actions[action_name] = action_info["action"]
-
-    SessionSM = StateMachineMetaclass(
-        "SessionSM",
-        (StateMachine,),
-        {"states": States(states), **transitions},  # type: ignore[call-arg]
-    )
-    session_sm: StateMachine = SessionSM()  # type: ignore[no-redef]
-
-    return session_sm, transitions, leaf_actions
-
-
-def get_current_scene(scenes: list[Scene], region: Region | None = None) -> Scene:
-    """Get the current scene from the list of scenes."""
-    current_scenes = [scene for scene in scenes if scene.is_on_screen(region)]
-    if len(current_scenes) == 1:
-        return current_scenes[0]
-    elif len(current_scenes) > 1:
-        raise SceneRecognitionError(
-            f"Multiple scenes are currently on screen.\n{' '.join(str(scene) for scene in current_scenes)}"
-        )
-    else:
-        raise SceneRecognitionError("No scene is currently on screen.")
-
-
-class Session:
-    """A session manages the state machine for GUI automation scenes."""
-
-    def __init__(self, scenes: list[Scene]):
-        self._scenes_list = scenes
-        self._scenes_dict = {scene.name: scene for scene in scenes}
-
-        # Create dynamic StateMachine class and instantiate it
-        self._sm, self.transitions, self.leaf_actions = build_dynamic_state_machine(
-            scenes
-        )
-        self.graph: nx.MultiDiGraph = nx.nx_pydot.from_pydot(self._sm._graph())
-
-    @property
-    def current_scene(self) -> State:
-        """Get the current state."""
-        return self._sm.current_state
-
-    def expect(self, target_scene: Scene, **kwargs):
-        """Navigate to a specific scene."""
-        if target_scene.is_on_screen():
-            return
-
-        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,
-            )
-        )
-        if len(all_paths) == 0:
-            raise SceneRecognitionError(
-                f"No path found from {present_scene.name} to {target_scene.name}"
-            )
-        elif len(all_paths) > 1:
-            raise SceneRecognitionError(
-                f"Multiple paths found from {present_scene.name} to {target_scene.name}"
-            )
-
-        path = all_paths[0]
-        events: list[str] = [
-            self.graph.get_edge_data(path[i], path[i + 1])[0]["label"]  # type: ignore
-            for i in range(len(path) - 1)
-        ]
-
-        for event in events:
-            self._sm.send(event, **kwargs)
-
-    def invoke(self, action_name: str, **kwargs):
-        """Invoke an action in the current scene."""
-        event_name = f"event_{action_name}"
-        transition = next(
-            (tr for tr_name, tr in self.transitions.items() if tr_name == event_name),
-            None,
-        )
-        if transition:
-            return self._sm.send(event_name, **kwargs)
-
-        leaf_action = next(
-            (
-                action
-                for name, action in self.leaf_actions.items()
-                if name == action_name
-            ),
-            None,
-        )
-        if leaf_action:
-            return leaf_action(**kwargs)
-
-        raise ValueError(
-            f"Action '{action_name}' not found in current scene '{self.current_scene.name}'"
-        )
-
-    def __repr__(self):
-        current = self.current_scene
-        current_name = current.name if current else "None"
-        return (
-            f"Session(scenes={list(self._scenes_dict.keys())}, current={current_name})"
-        )
+from __future__ import annotations
+
+from typing import Callable
+
+import networkx as nx
+from statemachine import State, StateMachine
+from statemachine.factory import StateMachineMetaclass
+from statemachine.states import States
+from statemachine.transition_list import TransitionList
+
+from .scene import Scene
+from .screen import Region
+
+
+class SceneRecognitionError(Exception):
+    pass
+
+
+def build_dynamic_state_machine(
+    scenes: list[Scene],
+) -> tuple[StateMachine, dict[str, TransitionList], dict[str, Callable]]:
+    """Create a dynamic StateMachine class from scenes using StateMachineMetaclass."""
+
+    states = {scene.name: scene for scene in scenes}
+    transitions = {}
+    leaf_actions = {}
+    for scene in scenes:
+        for action_name, action_info in scene.actions.items():
+            target_scene = action_info["transitions_to"]
+            if target_scene is not None:
+                event_name = f"event_{action_name}"
+                new_transition = scene.to(target_scene, event=event_name)
+                new_transition.on(action_info["action"])
+                transitions[event_name] = new_transition
+            else:
+                leaf_actions[action_name] = action_info["action"]
+
+    SessionSM = StateMachineMetaclass(
+        "SessionSM",
+        (StateMachine,),
+        {"states": States(states), **transitions},  # type: ignore[call-arg]
+    )
+    session_sm: StateMachine = SessionSM()  # type: ignore[no-redef]
+
+    return session_sm, transitions, leaf_actions
+
+
+def get_current_scene(scenes: list[Scene], region: Region | None = None) -> Scene:
+    """Get the current scene from the list of scenes."""
+    current_scenes = [scene for scene in scenes if scene.is_on_screen(region)]
+    if len(current_scenes) == 1:
+        return current_scenes[0]
+    elif len(current_scenes) > 1:
+        raise SceneRecognitionError(
+            f"Multiple scenes are currently on screen.\n{' '.join(str(scene) for scene in current_scenes)}"
+        )
+    else:
+        raise SceneRecognitionError("No scene is currently on screen.")
+
+
+class Session:
+    """A session manages the state machine for GUI automation scenes."""
+
+    def __init__(self, scenes: list[Scene]):
+        self._scenes_list = scenes
+        self._scenes_dict = {scene.name: scene for scene in scenes}
+
+        # Create dynamic StateMachine class and instantiate it
+        self._sm, self.transitions, self.leaf_actions = build_dynamic_state_machine(
+            scenes
+        )
+        self.graph: nx.MultiDiGraph = nx.nx_pydot.from_pydot(self._sm._graph())
+
+    @property
+    def current_scene(self) -> State:
+        """Get the current state."""
+        return self._sm.current_state
+
+    def expect(self, target_scene: Scene, **kwargs):
+        """Navigate to a specific scene."""
+        if target_scene.is_on_screen():
+            return
+
+        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,
+            )
+        )
+        if len(all_paths) == 0:
+            raise SceneRecognitionError(
+                f"No path found from {present_scene.name} to {target_scene.name}"
+            )
+        elif len(all_paths) > 1:
+            raise SceneRecognitionError(
+                f"Multiple paths found from {present_scene.name} to {target_scene.name}"
+            )
+
+        path = all_paths[0]
+        events: list[str] = [
+            self.graph.get_edge_data(path[i], path[i + 1])[0]["label"]  # type: ignore
+            for i in range(len(path) - 1)
+        ]
+
+        for event in events:
+            self._sm.send(event, **kwargs)
+
+    def invoke(self, action_name: str, **kwargs):
+        """Invoke an action in the current scene."""
+        event_name = f"event_{action_name}"
+        transition = next(
+            (tr for tr_name, tr in self.transitions.items() if tr_name == event_name),
+            None,
+        )
+        if transition:
+            return self._sm.send(event_name, **kwargs)
+
+        leaf_action = next(
+            (
+                action
+                for name, action in self.leaf_actions.items()
+                if name == action_name
+            ),
+            None,
+        )
+        if leaf_action:
+            return leaf_action(**kwargs)
+
+        raise ValueError(
+            f"Action '{action_name}' not found in current scene '{self.current_scene.name}'"
+        )
+
+    def __repr__(self):
+        current = self.current_scene
+        current_name = current.name if current else "None"
+        return (
+            f"Session(scenes={list(self._scenes_dict.keys())}, current={current_name})"
+        )

pyautoscene/utils.py

@@ -1,25 +1,25 @@
-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)
+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)

{pyautoscene-0.2.0.dist-info → pyautoscene-0.2.1.dist-info}/METADATA

@@ -1,14 +1,18 @@
 Metadata-Version: 2.4
 Name: pyautoscene
-Version: 0.2.0
+Version: 0.2.1
 Summary: Advance GUI automation
 Author-email: pritam-dey3 <pritam.pritamdey.984@gmail.com>
 License-File: LICENSE
 Requires-Python: >=3.13
 Requires-Dist: networkx>=3.5
+Requires-Dist: opencv-python-headless>=4.12.0.88
 Requires-Dist: pillow>=11.3.0
 Requires-Dist: pyautogui>=0.9.54
 Requires-Dist: python-statemachine[diagrams]
+Provides-Extra: ocr
+Requires-Dist: onnxruntime>=1.22.0; extra == 'ocr'
+Requires-Dist: rapidocr>=3.2.0; extra == 'ocr'
 Description-Content-Type: text/markdown
 
 # PyAutoScene

pyautoscene-0.2.1.dist-info/RECORD

@@ -0,0 +1,13 @@
+pyautoscene/__init__.py,sha256=clSA3hhv4eGTi1C4oN4BKX7i5ILZOy4ABVO0wFUfSXo,167
+pyautoscene/ocr.py,sha256=y_JpmFLwUxS7PKeKjsF1o5r354j004y2bJNzfIcRei0,2168
+pyautoscene/ocr_config.yaml,sha256=EGaKX1a-LyWk0gtI2wUo04LraFqGJ3aZnQ5NCPbgDYI,2231
+pyautoscene/references.py,sha256=tsYVMhdawLCSk-leh0C9k-DwlLaP1niIHFR-bY3djcQ,2482
+pyautoscene/scene.py,sha256=to-hpwODLKpD0vSHbxHvnPhV7JicEV5hmcxXC0yX5Z8,1997
+pyautoscene/screen.py,sha256=26xPZ2PCE6jy8dKUFhMbCgD7XFI1McboB2E04HgSO2Q,2189
+pyautoscene/session.py,sha256=Bm5E3nNKhpdE-ND44zeRvWvO2VOMU2WAcgE65w7iBMc,4726
+pyautoscene/utils.py,sha256=v7TD8IUyY1jEyOXJ6520fNTpLY3k0-UxxTwSuoEtG_8,769
+pyautoscene-0.2.1.dist-info/METADATA,sha256=S8oK-l3AQtKodp5PRMt2kdV2fL7yxD6E9Sn_tQUmpHA,6068
+pyautoscene-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+pyautoscene-0.2.1.dist-info/entry_points.txt,sha256=6aKjylfDivCRMrJasIIi7ICU4fZR-8HjcOHhRmHpYpQ,49
+pyautoscene-0.2.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+pyautoscene-0.2.1.dist-info/RECORD,,