apparser 1.0.0__tar.gz

apparser-1.0.0/LICENSE.md

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025 Terochkin A.S
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

apparser-1.0.0/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: apparser
+Version: 1.0.0
+Summary: Apparser is a Python library designed for automating desktop applications and managing UI interfaces using artificial intelligence, such as OCR or object detection models. 
+Author-email: "Terochkin A.S" <apparser.development@gmail.com>
+Project-URL: Docs, https://apparser-development.github.io/apparser/
+Project-URL: Repository, https://github.com/apparser-development/apparser
+Project-URL: Issues, https://github.com/apparser-development/apparser/issues
+Keywords: automation,desktop-automation,gui-automation,ui-automation,computer-vision,object-detection,ocr,ui,cv,yolo,text-recognition,screen-recognition,window-management,mouse-automation,keyboard-automation,speech-synthesis,tts,app-control
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Operating System :: Microsoft :: Windows :: Windows 10
+Classifier: Operating System :: Microsoft :: Windows :: Windows 11
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Environment :: X11 Applications
+Classifier: Environment :: Win32 (MS Windows)
+Classifier: Environment :: MacOS X :: Aqua
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: appwindows>=1.3.0
+Requires-Dist: PyAutoGui>=0.9.0
+Requires-Dist: numpy>=1.20
+Requires-Dist: pillow>=11.0
+Requires-Dist: screeninfo>=0.8
+Requires-Dist: thefuzz>=0.20.0
+Provides-Extra: cv
+Requires-Dist: ultralytics>=8.4.30; extra == "cv"
+Provides-Extra: ocr
+Requires-Dist: easyocr<2.0,>=1.7.2; extra == "ocr"
+Requires-Dist: paddleocr>=3.5.0; extra == "ocr"
+Requires-Dist: paddlepaddle>=3.3.1; extra == "ocr"
+Provides-Extra: speak
+Requires-Dist: ChatTTS; extra == "speak"
+Requires-Dist: sounddevice; extra == "speak"
+Requires-Dist: torch; extra == "speak"
+Provides-Extra: all
+Requires-Dist: apparser[cv]; extra == "all"
+Requires-Dist: apparser[ocr]; extra == "all"
+Requires-Dist: apparser[speak]; extra == "all"
+Dynamic: license-file
+
+<img src="https://raw.githubusercontent.com/apparser-development/apparser/refs/heads/master/apparser.svg" alt="" width="40%">
+
+[![Documentation](https://img.shields.io/badge/docs-pages-green)](https://apparser-development.github.io/apparser/)
+[![unit_tests](https://github.com/apparser-development/appwindows/actions/workflows/unit_tests.yml/badge.svg)](https://github.com/apparser-development/appwindows/actions/workflows/unit_tests.yml)
+<br>
+[![Github](https://img.shields.io/badge/github-repo-green)](https://github.com/apparser-development/apparser)
+[![Issues](https://img.shields.io/badge/github-issues-green)](https://github.com/apparser-development/apparser/issues)
+
+# Apparser
+Apparser is a Python library designed for automating desktop applications and managing UI interfaces using artificial intelligence, such as OCR or object detection models.
+# Install
+```bash
+pip install apparser
+```
+
+# Examples
+
+1) Open terminal and write "Hello World!"
+```python
+from apparser import App
+from apparser.geometry import RelativelyPoint
+from apparser.instructions import Algorithm, MouseClickTo, WriteText, Sleep
+
+algorithm = Algorithm([
+        Sleep(1), # Wait for the application to open.
+        MouseClickTo(RelativelyPoint(0.5, 0.5)), # Click to window center for start writing
+        WriteText("Hello World") # Write text
+])
+
+app = App("notepad", window_title="Notepad")
+
+algorithm.perform(app.ui)
+```
+
+# Docs
+All documentation <a href="https://apparser-development.github.io/apparser/">here</a> <br>
+Link to <a href="https://pypi.org/project/apparser/">PyPi</a>
+
+# For Developers
+1) If something doesn't work - open issue.
+2) If you want something fixed - open issue.
+3) If you can help with the library - email.
+
+apparser.development@gmail.com
+
+Any help in development is welcome)!

apparser-1.0.0/README.md

@@ -0,0 +1,46 @@
+<img src="https://raw.githubusercontent.com/apparser-development/apparser/refs/heads/master/apparser.svg" alt="" width="40%">
+
+[![Documentation](https://img.shields.io/badge/docs-pages-green)](https://apparser-development.github.io/apparser/)
+[![unit_tests](https://github.com/apparser-development/appwindows/actions/workflows/unit_tests.yml/badge.svg)](https://github.com/apparser-development/appwindows/actions/workflows/unit_tests.yml)
+<br>
+[![Github](https://img.shields.io/badge/github-repo-green)](https://github.com/apparser-development/apparser)
+[![Issues](https://img.shields.io/badge/github-issues-green)](https://github.com/apparser-development/apparser/issues)
+
+# Apparser
+Apparser is a Python library designed for automating desktop applications and managing UI interfaces using artificial intelligence, such as OCR or object detection models.
+# Install
+```bash
+pip install apparser
+```
+
+# Examples
+
+1) Open terminal and write "Hello World!"
+```python
+from apparser import App
+from apparser.geometry import RelativelyPoint
+from apparser.instructions import Algorithm, MouseClickTo, WriteText, Sleep
+
+algorithm = Algorithm([
+        Sleep(1), # Wait for the application to open.
+        MouseClickTo(RelativelyPoint(0.5, 0.5)), # Click to window center for start writing
+        WriteText("Hello World") # Write text
+])
+
+app = App("notepad", window_title="Notepad")
+
+algorithm.perform(app.ui)
+```
+
+# Docs
+All documentation <a href="https://apparser-development.github.io/apparser/">here</a> <br>
+Link to <a href="https://pypi.org/project/apparser/">PyPi</a>
+
+# For Developers
+1) If something doesn't work - open issue.
+2) If you want something fixed - open issue.
+3) If you can help with the library - email.
+
+apparser.development@gmail.com
+
+Any help in development is welcome)!

apparser-1.0.0/apparser/__init__.py

@@ -0,0 +1 @@
+from apparser.core import *

apparser-1.0.0/apparser/core/__init__.py

@@ -0,0 +1,4 @@
+from apparser.core.app import App
+from apparser.core.ui import BaseUi, DesktopUi, CoordinatesUi, WindowUi, WindowByDisplayUi
+
+__all__ = ["App", "BaseUi", "DesktopUi", "CoordinatesUi", "WindowUi", "WindowByDisplayUi"]

apparser-1.0.0/apparser/core/app.py

@@ -0,0 +1,95 @@
+import os
+import subprocess
+import time
+
+from appwindows import get_finder
+from appwindows.exceptions import WindowDoesNotFoundException, WindowDoesNotValidException
+
+from apparser.core.ui import WindowUi, BaseUi
+
+
+class App:
+    """Manage an application process and its UI wrapper."""
+
+    def __init__(self, path_to_exe: str,
+                 window_title: str | None = None,
+                 timeout: float = 1):
+        """Initialize an application controller.
+
+        :param path_to_exe: Path to the executable file.
+        :type path_to_exe: str
+        :param window_title: Title of the window to attach to.
+        :type window_title: str
+        :param timeout: Delay before the window lookup starts.
+        :type timeout: float
+        :raises TypeError: If any argument has an invalid type.
+        """
+        if not isinstance(path_to_exe, str):
+            raise TypeError('path_to_exe must be a string')
+
+        if window_title is not None and not isinstance(window_title, str):
+            raise TypeError('window_title must be a string')
+
+        if not (isinstance(timeout, float) or isinstance(timeout, int)):
+            raise TypeError('timeout must be a number')
+
+        self.__window_finder = get_finder()
+        self.__process: subprocess.Popen | None = None
+        self.__path = path_to_exe
+        self.__timeout = timeout
+        self.__window_title_name: str = window_title
+        self.__ui: BaseUi | None = None
+        self.start_app()
+
+    def __find_window_by_title(self):
+        try:
+            window = self.__window_finder.get_window_by_title(self.__window_title_name)
+            self.__ui = WindowUi(window)
+        except WindowDoesNotFoundException:
+            pass
+
+    def __find_window_by_process_id(self, process_id: int):
+        try:
+            window = self.__window_finder.get_window_by_process_id(process_id)
+            self.__ui = WindowUi(window)
+        except WindowDoesNotFoundException:
+            pass
+
+    def start_app(self):
+        """Start the application process and bind its UI.
+
+        :raises WindowDoesNotValidException: If the window is not found or the application cannot be opened.
+        """
+        if self.__window_title_name is not None:
+            self.__find_window_by_title()
+        if self.__ui is not None:
+            return
+        window_processes = [i.get_process_id() for i in get_finder().get_all_windows()]
+        self.__process = subprocess.Popen([self.__path])
+        time.sleep(self.__timeout)
+        self.__find_window_by_process_id(os.getpid())
+        for i in get_finder().get_all_windows():
+            if self.__ui is not None:
+                return
+            if i.get_process_id() not in window_processes:
+                self.__find_window_by_process_id(i.get_process_id())
+        if self.__ui is not None:
+            return
+        self.__find_window_by_title()
+        if self.__ui is not None:
+            raise WindowDoesNotValidException()
+
+    def stop_app(self):
+        """Close the application window and stop the process."""
+        self.ui.window.close()
+        if self.__process is not None:
+            self.__process.kill()
+
+    @property
+    def ui(self) -> BaseUi:
+        """Return the UI wrapper for the running application.
+
+        :return: UI wrapper bound to the application window.
+        :rtype: BaseUi
+        """
+        return self.__ui

apparser-1.0.0/apparser/core/ui/__init__.py

@@ -0,0 +1,8 @@
+from apparser.core.ui.base import BaseUi
+from apparser.core.ui.desktop import DesktopUi
+from apparser.core.ui.coordinates import CoordinatesUi
+from apparser.core.ui.window import WindowUi
+from apparser.core.ui.window_by_display import WindowByDisplayUi
+
+
+__all__ = ["BaseUi", "DesktopUi", "CoordinatesUi", "WindowUi", "WindowByDisplayUi"]

apparser-1.0.0/apparser/core/ui/base.py

@@ -0,0 +1,51 @@
+import abc
+
+import numpy
+from appwindows import Window
+
+from apparser.geometry import Point, RelativelyPoint
+
+
+class BaseUi(abc.ABC):
+    """Define the common interface for UI coordinate systems."""
+
+    @abc.abstractmethod
+    def point_to_global(self, coordinates: Point | RelativelyPoint) -> Point:
+        """Convert coordinates to the global screen space.
+
+        :param coordinates: Local or relative coordinates to convert.
+        :type coordinates: Point | RelativelyPoint
+        :return: Converted global point.
+        :rtype: Point
+        """
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def point_to_local(self, coordinates: Point) -> Point:
+        """Convert coordinates to the local UI space.
+
+        :param coordinates: Global point to convert.
+        :type coordinates: Point
+        :return: Converted local point.
+        :rtype: Point
+        """
+        raise NotImplementedError()
+
+    @abc.abstractmethod
+    def get_screenshot(self) -> numpy.ndarray:
+        """Capture the current UI screenshot.
+
+        :return: Screenshot data.
+        :rtype: numpy.ndarray
+        """
+        raise NotImplementedError()
+
+    @property
+    @abc.abstractmethod
+    def window(self) -> Window:
+        """Return the window associated with the UI context.
+
+        :return: Underlying application window.
+        :rtype: Window
+        """
+        raise NotImplementedError()

apparser-1.0.0/apparser/core/ui/coordinates.py

@@ -0,0 +1,118 @@
+from functools import singledispatchmethod
+
+import numpy
+from appwindows import Window
+from appwindows.geometry import Size
+
+from apparser.core.ui.base import BaseUi
+from apparser.geometry import Point, RelativelyPoint
+
+
+class CoordinatesUi(BaseUi):
+    """Represent a UI region defined by two points inside another UI context."""
+
+    def __init__(
+        self,
+        from_ui: BaseUi,
+        point_one: Point | RelativelyPoint,
+        point_two: Point | RelativelyPoint
+    ):
+        """Initialize a nested coordinate-based UI context.
+
+        :param from_ui: Source UI used as a parent context.
+        :type from_ui: BaseUi
+        :param point_one: First point of the nested region.
+        :type point_one: Point | RelativelyPoint
+        :param point_two: Second point of the nested region or region size.
+        :type point_two: Point | RelativelyPoint | Size
+        :raises TypeError: If any argument has an invalid type.
+        """
+        if not isinstance(from_ui, BaseUi):
+            raise TypeError('from_ui must be BaseUi')
+
+        if not isinstance(point_one, (Point, RelativelyPoint)):
+            raise TypeError('point1 must be Point or RelativelyPoint')
+
+        elif not isinstance(point_two, (Point, RelativelyPoint)):
+            raise TypeError('point2 must be Point, RelativelyPoint')
+
+        self.__from_ui = from_ui
+        self.__point_one = point_one
+        self.__point_two = point_two
+
+    def __point_to_main_ui_local(self, point: Point | RelativelyPoint) -> Point:
+        if isinstance(point, RelativelyPoint):
+            return self.__from_ui.point_to_local(self.__from_ui.point_to_global(point))
+        return point
+
+    def __get_local_bounds(self) -> tuple[Point, Point]:
+        point1 = self.__point_to_main_ui_local(self.__point_one)
+        point2 = self.__point_to_main_ui_local(self.__point_two)
+        left_top_point = Point(
+            min(point1.x, point2.x),
+            min(point1.y, point2.y),
+        )
+        right_bottom_point = Point(
+            max(point1.x, point2.x),
+            max(point1.y, point2.y),
+        )
+        return left_top_point, right_bottom_point
+
+    @singledispatchmethod
+    def point_to_global(self, coordinates: Point | RelativelyPoint) -> Point:
+        """Convert region coordinates to the global screen space.
+
+        :param coordinates: Local or relative coordinates to convert.
+        :type coordinates: Point | RelativelyPoint
+        :return: Converted global point.
+        :rtype: Point
+        """
+        raise NotImplementedError()
+
+    @point_to_global.register(Point)
+    def _(self, coordinates: Point) -> Point:
+        left_top_point, _ = self.__get_local_bounds()
+        return self.__from_ui.point_to_global(coordinates + left_top_point)
+
+    @point_to_global.register(RelativelyPoint)
+    def _(self, coordinates: RelativelyPoint) -> Point:
+        left_top_point, right_bottom_point = self.__get_local_bounds()
+        width = abs(round(right_bottom_point.x - left_top_point.x))
+        height = abs(round(right_bottom_point.y - left_top_point.y))
+        x = round(coordinates.x * width)
+        y = round(coordinates.y * height)
+        local_point = Point(x, y)
+        return self.point_to_global(local_point)
+
+    def point_to_local(self, coordinates: Point) -> Point:
+        """Convert global coordinates to the local region space.
+
+        :param coordinates: Global point to convert.
+        :type coordinates: Point
+        :return: Converted local point.
+        :rtype: Point
+        """
+        left_top_point, _ = self.__get_local_bounds()
+        return self.__from_ui.point_to_local(coordinates) - left_top_point
+
+    def get_screenshot(self) -> numpy.ndarray:
+        """Capture a screenshot cropped to the nested region.
+
+        :return: Screenshot data for the nested region.
+        :rtype: numpy.ndarray
+        """
+        screenshot = self.__from_ui.get_screenshot()
+        left_top_point, right_bottom_point = self.__get_local_bounds()
+        return screenshot[
+            left_top_point.y:right_bottom_point.y,
+            left_top_point.x:right_bottom_point.x,
+        ]
+
+    @property
+    def window(self) -> Window:
+        """Return the parent window for the nested region.
+
+        :return: Underlying parent window.
+        :rtype: Window
+        """
+        return self.__from_ui.window

apparser-1.0.0/apparser/core/ui/desktop.py

@@ -0,0 +1,72 @@
+from functools import singledispatchmethod
+
+import numpy
+from appwindows import Window
+from PIL import ImageGrab
+from screeninfo import get_monitors
+
+from apparser.core.ui.base import BaseUi
+from apparser.geometry import Point, RelativelyPoint
+from apparser.exceptions import WindowActionWithDesktopException
+
+
+class DesktopUi(BaseUi):
+    """Represent the full desktop as a UI context."""
+
+    def __init__(self, display_id: int = 0):
+        """Initialize a desktop UI context.
+
+        :param display_id: Monitor index used for relative coordinates.
+        :type display_id: int
+        """
+        self.__display_id = display_id
+
+    @singledispatchmethod
+    def point_to_global(self, coordinates: Point | RelativelyPoint) -> Point:
+        """Convert desktop coordinates to the global screen space.
+
+        :param coordinates: Local or relative coordinates to convert.
+        :type coordinates: Point | RelativelyPoint
+        :return: Converted global point.
+        :rtype: Point
+        """
+        raise NotImplementedError()
+
+    @point_to_global.register(Point)
+    def _(self, coordinates: Point):
+        return coordinates
+
+    @point_to_global.register(RelativelyPoint)
+    def _(self, coordinates: RelativelyPoint):
+        monitor = get_monitors()[self.__display_id]
+        x = round(coordinates.x * monitor.width)
+        y = round(coordinates.y * monitor.height)
+        local_point = Point(x, y)
+        return self.point_to_global(local_point)
+
+    def point_to_local(self, coordinates: Point) -> Point:
+        """Convert global coordinates to the desktop local space.
+
+        :param coordinates: Global point to convert.
+        :type coordinates: Point
+        :return: Converted local point.
+        :rtype: Point
+        """
+        return Point(coordinates.x, coordinates.y)
+
+    def get_screenshot(self) -> numpy.ndarray:
+        """Capture a screenshot of the desktop.
+
+        :return: Desktop screenshot data.
+        :rtype: numpy.ndarray
+        """
+        screenshot = ImageGrab.grab()
+        return numpy.asarray(screenshot)
+
+    @property
+    def window(self) -> Window:
+        """Raise an exception because the desktop has no window.
+
+        :raises WindowActionWithDesktopException: Always raised for desktop UI contexts.
+        """
+        raise WindowActionWithDesktopException()

apparser-1.0.0/apparser/core/ui/window.py

@@ -0,0 +1,75 @@
+from functools import singledispatchmethod
+
+import numpy
+
+from appwindows import Window
+from appwindows.geometry import Point, Size
+
+from apparser.core.ui.base import BaseUi
+from apparser.geometry.relatively_point import RelativelyPoint
+
+
+class WindowUi(BaseUi):
+    """Represent a window as a UI context."""
+
+    def __init__(self, window: Window):
+        """Initialize a window UI context.
+
+        :param window: Window instance to wrap.
+        :type window: Window
+        :raises TypeError: If ``window`` has an invalid type.
+        """
+        if not isinstance(window, Window):
+            raise TypeError('window must be Window')
+
+        self.__window = window
+
+    @singledispatchmethod
+    def point_to_global(self, coordinates: Point | RelativelyPoint) -> Point:
+        """Convert window coordinates to the global screen space.
+
+        :param coordinates: Local or relative coordinates to convert.
+        :type coordinates: Point | RelativelyPoint
+        :return: Converted global point.
+        :rtype: Point
+        """
+        raise NotImplementedError()
+
+    @point_to_global.register(Point)
+    def _(self, coordinates: Point):
+        return coordinates + self.__window.get_points().left_top
+
+    @point_to_global.register(RelativelyPoint)
+    def _(self, coordinates: RelativelyPoint):
+        size: Size = self.__window.get_size()
+        x = round(coordinates.x * size.width)
+        y = round(coordinates.y * size.height)
+        local_point = Point(x, y)
+        return self.point_to_global(local_point)
+
+    def point_to_local(self, coordinates: Point) -> Point:
+        """Convert global coordinates to the window local space.
+
+        :param coordinates: Global point to convert.
+        :type coordinates: Point
+        :return: Converted local point.
+        :rtype: Point
+        """
+        return coordinates - self.__window.get_points().left_top
+
+    def get_screenshot(self) -> numpy.ndarray:
+        """Capture a screenshot of the window.
+
+        :return: Window screenshot data.
+        :rtype: numpy.ndarray
+        """
+        return self.__window.get_screenshot()
+
+    @property
+    def window(self):
+        """Return the wrapped window instance.
+
+        :return: Wrapped window.
+        :rtype: Window
+        """
+        return self.__window

apparser-1.0.0/apparser/core/ui/window_by_display.py

@@ -0,0 +1,90 @@
+from functools import singledispatchmethod
+
+import numpy
+from PIL import ImageGrab
+
+from appwindows import Window
+from appwindows.geometry import Point, Size
+
+from apparser.core.ui.base import BaseUi
+from apparser.geometry.relatively_point import RelativelyPoint
+
+
+class WindowByDisplayUi(BaseUi):
+    """
+    Represent a window as a display-captured UI context.
+    Unlike the WindowUi class, it retrieves the application's image based on its borders rather than from the graphical shell.
+    """
+
+    def __init__(self, window: Window) -> None:
+        """Initialize a display-captured window UI context.
+
+        :param window: Window instance to wrap.
+        :type window: Window
+        :raises TypeError: If ``window`` has an invalid type.
+        """
+        if not isinstance(window, Window):
+            raise TypeError('window must be Window')
+
+        self.__window = window
+
+    @singledispatchmethod
+    def point_to_global(self, coordinates: Point | RelativelyPoint) -> Point:
+        """Convert window coordinates to the global screen space.
+
+        :param coordinates: Local or relative coordinates to convert.
+        :type coordinates: Point | RelativelyPoint
+        :return: Converted global point.
+        :rtype: Point
+        """
+        raise NotImplementedError()
+
+    @point_to_global.register(Point)
+    def _(self, coordinates: Point) -> Point:
+        return coordinates + self.__window.get_points().left_top
+
+    @point_to_global.register(RelativelyPoint)
+    def _(self, coordinates: RelativelyPoint) -> Point:
+        size: Size = self.__window.get_size()
+        x = round(coordinates.x * size.width)
+        y = round(coordinates.y * size.height)
+        local_point = Point(x, y)
+        return self.point_to_global(local_point)
+
+    def point_to_local(self, coordinates: Point) -> Point:
+        """Convert global coordinates to the window local space.
+
+        :param coordinates: Global point to convert.
+        :type coordinates: Point
+        :return: Converted local point.
+        :rtype: Point
+        """
+        return coordinates - self.__window.get_points().left_top
+
+    def get_screenshot(self) -> numpy.ndarray:
+        """Capture a screenshot of the window from the display.
+
+        :return: Window screenshot data captured by window bounds.
+        :rtype: numpy.ndarray
+        """
+        left_top = self.__window.get_points().left_top
+        size: Size = self.__window.get_size()
+        screenshot = ImageGrab.grab(
+            bbox=(
+                left_top.x,
+                left_top.y,
+                left_top.x + size.width,
+                left_top.y + size.height,
+            ),
+            all_screens=True,
+        )
+        return numpy.asarray(screenshot)
+
+    @property
+    def window(self) -> Window:
+        """Return the wrapped window instance.
+
+        :return: Wrapped window.
+        :rtype: Window
+        """
+        return self.__window