datalab-platform 0.0.1.dev0__py3-none-any.whl → 1.0.1__py3-none-any.whl

datalab/widgets/imagebackground.py

@@ -0,0 +1,111 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Image background selection dialog."""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+from guidata.configtools import get_icon
+from plotpy.builder import make
+from plotpy.plot import PlotDialog
+
+from datalab.adapters_plotpy import create_adapter_from_object
+from datalab.config import _
+from datalab.utils.qthelpers import resize_widget_to_parent
+
+if TYPE_CHECKING:
+    from plotpy.items import MaskedXYImageItem, RangeComputation2d, RectangleShape
+    from qtpy.QtWidgets import QWidget
+    from sigima.objects import ImageObj
+
+
+class ImageBackgroundDialog(PlotDialog):
+    """Image background selection dialog.
+
+    Args:
+        image: image object
+        parent: parent widget. Defaults to None.
+    """
+
+    def __init__(self, image: ImageObj, parent: QWidget | None = None) -> None:
+        self.__background: float | None = None
+        self.__rect_coords: tuple[float, float, float, float] | None = None
+        self.imageitem: MaskedXYImageItem | None = None
+        self.rectarea: RectangleShape | None = None
+        self.comput2d: RangeComputation2d | None = None
+        super().__init__(
+            title=_("Image background selection"), edit=True, parent=parent
+        )
+        self.setObjectName("backgroundselection")
+        if parent is None:
+            self.setWindowIcon(get_icon("DataLab.svg"))
+        else:
+            resize_widget_to_parent(self, aspect_ratio=1.0)
+        self.__image = image.copy()
+        self.__setup_dialog()
+
+    def test_compute_background(self) -> None:
+        """Method to test background computation."""
+        # Instead of waiting for Qt events, directly test the computation method
+        # by simulating what RangeComputation2d would do
+        x0, y0, x1, y1 = self.rectarea.get_rect()
+        x, y, z = self.imageitem.get_data(x0, y0, x1, y1)
+        self.__compute_background(x, y, z)
+
+    def __compute_background(
+        self,
+        x: np.ndarray,  # pylint: disable=unused-argument
+        y: np.ndarray,  # pylint: disable=unused-argument
+        z: np.ndarray,
+    ) -> float:
+        """Compute background value"""
+        self.__rect_coords = self.rectarea.get_rect()
+        self.__background = z.mean()
+        return self.__background
+
+    def __setup_dialog(self) -> None:
+        """Setup dialog box"""
+        obj = self.__image
+        self.imageitem = create_adapter_from_object(obj).make_item()
+        plot = self.get_plot()
+        if obj.is_uniform_coords:
+            x0, y0 = obj.x0, obj.y0
+            x1, y1 = obj.xc + obj.dx, obj.yc + obj.dy
+        else:
+            x0, y0 = obj.xcoords[0], obj.ycoords[0]
+            xc = (obj.xcoords[0] + obj.xcoords[-1]) / 2
+            yc = (obj.ycoords[0] + obj.ycoords[-1]) / 2
+            x1, y1 = xc, yc
+        self.rectarea = make.rectangle(x0, y0, x1, y1, _("Background area"))
+        self.comput2d = make.computation2d(
+            self.rectarea,
+            "TL",
+            _("Background value:") + " %g",
+            self.imageitem,
+            self.__compute_background,
+        )
+        for item in (self.imageitem, self.rectarea, self.comput2d):
+            plot.add_item(item)
+        plot.replot()
+        plot.set_active_item(self.rectarea)
+
+    def get_background(self) -> float:
+        """Get background value"""
+        return self.__background
+
+    def get_rect_coords(self) -> tuple[float, float, float, float]:
+        """Get rectangle coordinates
+
+        Returns:
+            tuple: rectangle coordinates (x0, y0, x1, y1)
+
+        Raises:
+            ValueError: if rectangle coordinates are not set
+        """
+        if self.__rect_coords is None:
+            raise ValueError("Rectangle coordinates not set")
+        return self.__rect_coords

datalab/widgets/instconfviewer.py

@@ -0,0 +1,175 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Module providing DataLab Installation configuration widget
+"""
+
+from __future__ import annotations
+
+import json
+import locale
+import os
+import platform
+import sys
+from importlib.metadata import distributions
+from pathlib import Path
+
+from guidata.configtools import get_icon
+from guidata.qthelpers import exec_dialog
+from qtpy import QtWidgets as QW
+from sigima.io.image import ImageIORegistry
+from sigima.io.signal import SignalIORegistry
+
+import datalab
+from datalab.config import APP_NAME, IS_FROZEN, Conf, _
+from datalab.plugins import PluginRegistry
+from datalab.widgets.fileviewer import FileViewerWidget, get_title_contents
+
+
+def decode_fs_string(string: bytes) -> str:
+    """Convert string from file system charset to unicode"""
+    charset = sys.getfilesystemencoding()
+    if charset is None:
+        charset = locale.getpreferredencoding()
+    return string.decode(charset)
+
+
+def get_installed_package_info() -> str:
+    """Get the list of installed packages with their versions"""
+    packages = [(dist.metadata["Name"], dist.version) for dist in distributions()]
+
+    # Sort alphabetically by package name
+    packages.sort(key=lambda x: x[0].lower())
+
+    # Determine column widths
+    name_width = max(len(name) for name, _ in packages)
+    version_width = max(len(version) for _, version in packages)
+
+    header = f"{'Package':{name_width}}   {'Version':{version_width}}"
+    separator = f"{'-' * name_width}   {'-' * version_width}"
+    result_lines = [header, separator]
+    for name, version in packages:
+        result_lines.append(f"{name:{name_width}}   {version:{version_width}}")
+
+    return os.linesep.join(result_lines)
+
+
+def get_manifest_package_info(manifest_path: Path) -> str:
+    """Get the list of packages from the build manifest file
+
+    Args:
+        manifest_path: Path to the manifest.json file
+
+    Returns:
+        Formatted string with package list and build information
+    """
+    try:
+        with open(manifest_path, "r", encoding="utf-8") as f:
+            manifest = json.load(f)
+
+        packages = list(manifest["packages"].items())
+        packages.sort(key=lambda x: x[0].lower())
+
+        # Determine column widths
+        name_width = max(len(name) for name, _ in packages)
+        version_width = max(len(version) for _, version in packages)
+
+        header = f"{'Package':{name_width}}   {'Version':{version_width}}"
+        separator = f"{'-' * name_width}   {'-' * version_width}"
+        result_lines = [
+            f"Build time: {manifest['build_time']}",
+            f"Python version: {manifest['python_version']}",
+            f"Build system: {manifest['system']} {manifest['release']}",
+            f"Architecture: {manifest['architecture']}",
+            "",
+            header,
+            separator,
+        ]
+        for name, version in packages:
+            result_lines.append(f"{name:{name_width}}   {version:{version_width}}")
+
+        return os.linesep.join(result_lines)
+    except Exception as e:
+        return f"Error reading manifest file: {e}"
+
+
+def get_install_info() -> str:
+    """Get DataLab installation informations
+
+    Returns:
+        str: installation informations
+    """
+    if IS_FROZEN:
+        #  Stand-alone version
+        more_info = "This is the Stand-alone version of DataLab."
+        more_info += os.linesep * 2
+
+        # Try to read manifest file from executable root directory
+        manifest_path = Path(sys.executable).parent / "manifest.json"
+        if manifest_path.exists():
+            more_info += get_manifest_package_info(manifest_path)
+        else:
+            more_info += "Manifest file not found."
+    else:
+        more_info = get_installed_package_info()
+    info = os.linesep.join(
+        [
+            f"DataLab v{datalab.__version__}",
+            "",
+            f"Machine type: {platform.machine()}",
+            f"Platform: {platform.platform()}",
+            f"Python v{sys.version}",
+            "",
+            more_info,
+        ]
+    )
+    return info
+
+
+class InstallConfigViewerWindow(QW.QDialog):
+    """Installation configuration window"""
+
+    def __init__(self, parent: QW.QWidget | None = None) -> None:
+        super().__init__(parent)
+        self.setObjectName("instviewer")
+        self.setWindowTitle(APP_NAME + " - " + _("Installation and configuration"))
+        self.setWindowIcon(get_icon("DataLab.svg"))
+        self.tabs = QW.QTabWidget(self)
+        uc_title, uc_contents = get_title_contents(Conf.get_filename())
+        plugins_io_contents = PluginRegistry.get_plugin_info(html=False)
+        for registry in (SignalIORegistry, ImageIORegistry):
+            plugins_io_contents += os.linesep + ("_" * 80) + os.linesep * 2
+            plugins_io_contents += registry.get_format_info(mode="text")
+        for title, contents, tab_icon, tab_title in (
+            (
+                _("Installation configuration"),
+                get_install_info(),
+                get_icon("libre-toolbox.svg"),
+                _("Installation configuration"),
+            ),
+            (
+                uc_title,
+                uc_contents,
+                get_icon("libre-gui-settings.svg"),
+                _("User configuration"),
+            ),
+            (
+                _("Plugins and I/O features"),
+                plugins_io_contents,
+                get_icon("libre-gui-plugin.svg"),
+                _("Plugins and I/O features"),
+            ),
+        ):
+            viewer = FileViewerWidget()
+            viewer.set_data(title, contents)
+            self.tabs.addTab(viewer, tab_icon, tab_title)
+        layout = QW.QVBoxLayout()
+        layout.addWidget(self.tabs)
+        self.setLayout(layout)
+        self.resize(800, 500)
+
+
+def exec_datalab_installconfig_dialog(parent: QW.QWidget | None = None) -> None:
+    """View DataLab installation configuration"""
+    dlg = InstallConfigViewerWindow(parent=parent)
+    exec_dialog(dlg)

datalab/widgets/logviewer.py

@@ -0,0 +1,80 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Module providing a log viewer widget, a log viewer window and DataLab's log viewer
+"""
+
+from __future__ import annotations
+
+import os.path as osp
+
+from guidata.configtools import get_icon
+from guidata.qthelpers import exec_dialog
+from qtpy import QtWidgets as QW
+
+from datalab.config import APP_NAME, Conf, _, get_old_log_fname
+from datalab.env import execenv
+from datalab.widgets.fileviewer import FileViewerWidget, get_title_contents
+
+
+class LogViewerWindow(QW.QDialog):
+    """Log viewer window"""
+
+    def __init__(self, fnames: list[str], parent: QW.QWidget | None = None) -> None:
+        super().__init__(parent)
+        self.setObjectName("logviewer")
+        self.setWindowTitle(APP_NAME + " - " + _("Log files"))
+        self.setWindowIcon(get_icon("DataLab.svg"))
+        self.tabs = QW.QTabWidget(self)
+        for fname in fnames:
+            if osp.isfile(fname):
+                title, contents = get_title_contents(fname)
+                if not contents.strip():
+                    continue
+                viewer = FileViewerWidget(language="Python")
+                viewer.set_data(title, contents)
+                self.tabs.addTab(viewer, get_icon("logs.svg"), osp.basename(fname))
+        layout = QW.QVBoxLayout()
+        layout.addWidget(self.tabs)
+        self.setLayout(layout)
+        self.resize(900, 400)
+
+    @property
+    def is_empty(self) -> bool:
+        """Return True if there is no log available"""
+        return self.tabs.count() == 0
+
+
+def get_log_filenames() -> list[str]:
+    """Return log filenames"""
+    return [
+        Conf.main.traceback_log_path.get(),
+        Conf.main.faulthandler_log_path.get(),
+        get_old_log_fname(Conf.main.traceback_log_path.get()),
+        get_old_log_fname(Conf.main.faulthandler_log_path.get()),
+    ]
+
+
+def get_log_prompt_message() -> str | None:
+    """Return prompt message for log files, i.e. a message informing the user
+    whether log files were generated during last session or current session."""
+    avail = [osp.isfile(fname) for fname in get_log_filenames()]
+    if avail[0] or avail[1]:
+        return _("Log files were generated during current session.")
+    if avail[2] or avail[3]:
+        return _("Log files were generated during last session.")
+    return None
+
+
+def exec_datalab_logviewer_dialog(parent: QW.QWidget | None = None) -> None:
+    """View DataLab logs"""
+    fnames = [osp.normpath(fname) for fname in get_log_filenames() if osp.isfile(fname)]
+    dlg = LogViewerWindow(fnames, parent=parent)
+    if dlg.is_empty:
+        if not execenv.unattended:
+            QW.QMessageBox.information(
+                dlg, APP_NAME, _("Log files are currently empty.")
+            )
+        dlg.close()
+    else:
+        exec_dialog(dlg)

datalab/widgets/signalbaseline.py

@@ -0,0 +1,90 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Signal base line selection dialog."""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+from guidata.configtools import get_icon
+from plotpy.builder import make
+from plotpy.plot import PlotDialog
+
+from datalab.adapters_plotpy import CURVESTYLES, create_adapter_from_object
+from datalab.config import _
+from datalab.utils.qthelpers import resize_widget_to_parent
+
+if TYPE_CHECKING:
+    from plotpy.items import CurveItem, Marker, XRangeSelection
+    from qtpy.QtWidgets import QWidget
+    from sigima.objects import SignalObj
+
+
+class SignalBaselineDialog(PlotDialog):
+    """Signal baseline selection dialog.
+
+    Args:
+        signal: signal object
+        parent: parent widget. Defaults to None.
+    """
+
+    def __init__(self, signal: SignalObj, parent: QWidget | None = None) -> None:
+        self.__curve_styles = CURVESTYLES.style_generator()
+        self.__baseline: float | None = None
+        self.__x_range: tuple[float, float] = [np.nan, np.nan]
+        self.curve: CurveItem | None = None
+        self.cursor: Marker | None = None
+        self.xrange: XRangeSelection | None = None
+        super().__init__(title=_("Signal baseline selection"), edit=True, parent=parent)
+        self.setObjectName("baselineselection")
+        if parent is None:
+            self.setWindowIcon(get_icon("DataLab.svg"))
+        legend = make.legend("TR")
+        self.get_plot().add_item(legend)
+        self.__signal = signal.copy()
+        self.__setup_dialog()
+        resize_widget_to_parent(self, aspect_ratio=1.0)
+
+    def __setup_dialog(self) -> None:
+        """Setup dialog box"""
+        obj = self.__signal
+        with CURVESTYLES.alternative(self.__curve_styles):
+            self.curve = create_adapter_from_object(obj).make_item()
+        plot = self.get_plot()
+        plot.set_antialiasing(True)
+        plot.SIG_RANGE_CHANGED.connect(self.xrange_changed)
+        plot.SIG_MARKER_CHANGED.connect(self.cursor_changed)
+        self.cursor = make.hcursor(0.0, _("Base line") + " = %g")
+        self.cursor.set_movable(False)
+        self.xrange = make.xrange(obj.x[0], obj.x[int(0.2 * len(obj.x))])
+        for item in (self.curve, self.cursor, self.xrange):
+            plot.add_item(item)
+        plot.replot()
+        plot.set_active_item(self.xrange)
+        self.xrange_changed(self.xrange, *self.xrange.get_range())
+
+    # pylint: disable=unused-argument
+    def xrange_changed(self, item: XRangeSelection, xmin: float, xmax: float) -> None:
+        """X range changed"""
+        self.__x_range = sorted([xmin, xmax])
+        imin, imax = np.searchsorted(self.__signal.x, self.__x_range)
+        if imin == imax:
+            return
+        self.cursor.set_pos(0, np.mean(self.__signal.y[imin:imax]))
+        plot = self.get_plot()
+        plot.replot()
+
+    def cursor_changed(self, item: Marker) -> None:
+        """Cursor changed"""
+        _x, self.__baseline = item.get_pos()
+
+    def get_baseline(self) -> float:
+        """Get baseline"""
+        return self.__baseline
+
+    def get_x_range(self) -> tuple[float, float]:
+        """Get x range"""
+        return self.__x_range

datalab/widgets/signalcursor.py

@@ -0,0 +1,208 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Signal horizontal or vertical cursor selection dialog."""
+
+# pylint: disable=invalid-name  # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal
+
+import numpy as np
+from guidata.configtools import get_icon
+from plotpy.builder import make
+from plotpy.plot import PlotDialog
+from qtpy import QtGui as QG
+from qtpy import QtWidgets as QW
+from sigima.tools.signal.features import find_x_values_at_y
+
+from datalab.adapters_plotpy import CURVESTYLES, create_adapter_from_object
+from datalab.config import _
+from datalab.utils.qthelpers import block_signals, resize_widget_to_parent
+
+if TYPE_CHECKING:
+    from plotpy.items import CurveItem, Marker
+    from qtpy.QtWidgets import QWidget
+    from sigima.objects import SignalObj
+
+
+class SignalCursorDialog(PlotDialog):
+    """Signal horizontal or vertical cursor selection dialog.
+
+    Args:
+        signal: signal object
+        parent: parent widget. Defaults to None.
+    """
+
+    def __init__(
+        self,
+        signal: SignalObj,
+        cursor_orientation: Literal["horizontal", "vertical"],
+        parent: QWidget | None = None,
+    ) -> None:
+        assert cursor_orientation in (
+            "horizontal",
+            "vertical",
+        ), "cursor_orientation must be 'horizontal' or 'vertical'"
+        self.__curve_styles = CURVESTYLES.style_generator()
+        self.__cursor_orientation = cursor_orientation
+        self.__signal = signal
+        self.__x_value: float | None = None
+        self.__y_value: float | None = None
+        self.curve: CurveItem | None = None
+        self.hcursor: Marker | None = None
+        self.vcursor: Marker | None = None
+        self.xlineedit: QW.QLineEdit | None = None
+        self.ylineedit: QW.QLineEdit | None = None
+        if cursor_orientation == "horizontal":
+            title = _("Select X value with cursor")
+        else:
+            title = _("Select Y value with cursor")
+        super().__init__(title=title, edit=True, parent=parent)
+        self.setObjectName("SignalCursorDialog")
+        if parent is None:
+            self.setWindowIcon(get_icon("DataLab.svg"))
+        legend = make.legend("TR")
+        self.get_plot().add_item(legend)
+        self.__setup_dialog()
+        resize_widget_to_parent(self, aspect_ratio=1.0)
+
+    def __setup_dialog(self) -> None:
+        """Setup dialog box"""
+        apply_button = QW.QPushButton(_("Apply"))
+        apply_button.setIcon(get_icon("apply.svg"))
+        apply_button.setToolTip(_("Apply cursor position"))
+        xlabel = QW.QLabel("X=")
+        ylabel = QW.QLabel("Y=")
+        self.xlineedit = QW.QLineEdit()
+        self.xlineedit.editingFinished.connect(self.xlineedit_editing_finished)
+        self.xlineedit.setValidator(QG.QDoubleValidator())
+        self.ylineedit = QW.QLineEdit()
+        self.ylineedit.editingFinished.connect(self.ylineedit_editing_finished)
+        self.ylineedit.setValidator(QG.QDoubleValidator())
+        self.xlineedit.setReadOnly(self.__cursor_orientation == "horizontal")
+        self.xlineedit.setDisabled(self.__cursor_orientation == "horizontal")
+        self.ylineedit.setReadOnly(self.__cursor_orientation == "vertical")
+        self.ylineedit.setDisabled(self.__cursor_orientation == "vertical")
+        xygroup = QW.QGroupBox(_("Cursor position"))
+        xylayout = QW.QHBoxLayout()
+        xylayout.addWidget(xlabel)
+        xylayout.addWidget(self.xlineedit)
+        if self.__cursor_orientation == "vertical":
+            xylayout.addWidget(apply_button)
+            apply_button.clicked.connect(self.xlineedit_editing_finished)
+            xylayout.addStretch()
+            xylayout.addSpacing(10)
+        xylayout.addWidget(ylabel)
+        xylayout.addWidget(self.ylineedit)
+        if self.__cursor_orientation == "horizontal":
+            xylayout.addWidget(apply_button)
+            apply_button.clicked.connect(self.ylineedit_editing_finished)
+        xygroup.setLayout(xylayout)
+        self.button_layout.insertWidget(0, xygroup)
+
+        obj = self.__signal
+        with CURVESTYLES.alternative(self.__curve_styles):
+            self.curve = create_adapter_from_object(obj).make_item()
+        plot = self.get_plot()
+        plot.set_antialiasing(True)
+
+        xcursor = make.xcursor(np.mean(obj.x), np.mean(obj.y), "X = %g, Y = %g")
+        xcursor.set_selectable(False)
+        param = xcursor.markerparam
+        param.symbol.facecolor = "blue"
+        param.symbol.edgecolor = "cyan"
+        param.symbol.size = 9
+        param.line.style = "DotLine"
+        param.line.color = "blue"
+        param.line.width = 2.0
+        param.update_item(xcursor)
+
+        plot.SIG_MARKER_CHANGED.connect(self.cursor_changed)
+        if self.__cursor_orientation == "horizontal":
+            self.hcursor = make.hcursor(np.mean(obj.y), "Y = %g")
+            self.vcursor = xcursor
+            self.vcursor.setVisible(False)
+        else:
+            self.vcursor = make.vcursor(np.mean(obj.x), "X = %g")
+            self.hcursor = xcursor
+            self.hcursor.setVisible(False)
+        for item in (self.curve, self.vcursor, self.hcursor):
+            plot.add_item(item)
+        plot.replot()
+        if self.__cursor_orientation == "horizontal":
+            plot.set_active_item(self.hcursor)
+            self.cursor_changed(self.hcursor)
+        else:
+            plot.set_active_item(self.vcursor)
+            self.cursor_changed(self.vcursor)
+
+    def cursor_changed(self, item: Marker) -> None:
+        """Cursor changed"""
+        sig = self.__signal
+        plot = self.get_plot()
+        if self.__cursor_orientation == "horizontal" and item is self.hcursor:
+            _x, y = item.get_pos()
+            x = None
+            x_values = find_x_values_at_y(sig.x, sig.y, y)
+            if len(x_values) > 0:
+                x = x_values[0]
+                with block_signals(plot):
+                    self.vcursor.set_pos(x, y)
+            self.vcursor.setVisible(x is not None)
+            self.button_box.button(QW.QDialogButtonBox.Ok).setEnabled(x is not None)
+        elif self.__cursor_orientation == "vertical" and item is self.vcursor:
+            x, _y = item.get_pos()
+            y_index = np.searchsorted(self.__signal.x, x)
+            if x < self.__signal.x[0] or y_index >= len(self.__signal.y):
+                y = None
+            else:
+                y = self.__signal.y[y_index]
+                with block_signals(plot):
+                    self.hcursor.set_pos(x, y)
+                self.hcursor.setVisible(True)
+            self.hcursor.setVisible(y is not None)
+            self.button_box.button(QW.QDialogButtonBox.Ok).setEnabled(y is not None)
+        self.xlineedit.setText(f"{x:g}" if x is not None else "")
+        self.ylineedit.setText(f"{y:g}" if y is not None else "")
+        self.__x_value, self.__y_value = x, y
+
+    def xlineedit_editing_finished(self) -> None:
+        """X line edit editing finished"""
+        try:
+            x = float(self.xlineedit.text())
+            _x, y = self.vcursor.get_pos()
+            if self.__cursor_orientation == "horizontal":
+                self.hcursor.set_pos(x, y)
+            else:
+                self.vcursor.set_pos(x, y)
+        except ValueError:
+            pass
+        plot = self.get_plot()
+        plot.replot()
+
+    def ylineedit_editing_finished(self) -> None:
+        """Y line edit editing finished"""
+        try:
+            y = float(self.ylineedit.text())
+            x, _y = self.hcursor.get_pos()
+            if self.__cursor_orientation == "horizontal":
+                self.hcursor.set_pos(x, y)
+            else:
+                self.vcursor.set_pos(x, y)
+        except ValueError:
+            pass
+        plot = self.get_plot()
+        plot.replot()
+
+    def get_cursor_position(self) -> tuple[float, float]:
+        """Get cursor position"""
+        return self.__x_value, self.__y_value
+
+    def get_x_value(self) -> float:
+        """Get cursor x value"""
+        return self.__x_value
+
+    def get_y_value(self) -> float:
+        """Get cursor y value"""
+        return self.__y_value