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

datalab/widgets/warningerror.py

@@ -0,0 +1,223 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Module providing a warning/error message box
+"""
+
+import os.path as osp
+import re
+import subprocess
+import traceback
+
+from guidata.config import CONF
+from guidata.configtools import get_font
+from guidata.qthelpers import exec_dialog, get_std_icon
+from guidata.widgets.console.shell import PythonShellWidget
+from qtpy import QtCore as QC
+from qtpy import QtWidgets as QW
+
+from datalab.config import Conf, _, get_mod_source_dir
+
+
+def go_to_error(text: str) -> None:
+    """Go to error: open file with external editor, and go to line number
+
+    Args:
+        text (str): Error text
+    """
+    pattern = r'File "(.+)", line (\d+),'
+    match = re.search(pattern, text)
+    if match:
+        path = match.group(1)
+        line_number = match.group(2)
+        mod_src_dir = get_mod_source_dir()
+        if not osp.isfile(path) and mod_src_dir is not None:
+            otherpath = osp.join(mod_src_dir, path)
+            if not osp.isfile(otherpath):
+                # TODO: [P3] For frozen app, go to error is implemented only when the
+                # source code is available locally (development mode).
+                # How about using a web browser to open the source code on github?
+                return
+            path = otherpath
+        if not osp.isfile(path):
+            return  # File not found (unhandled case)
+        fdict = {"path": path, "line_number": line_number}
+        args = Conf.console.external_editor_args.get().format(**fdict).split(" ")
+        editor_path = Conf.console.external_editor_path.get()
+        subprocess.run([editor_path] + args, shell=True, check=False)
+
+
+def insert_spaces(text: str, nbchars: int) -> str:
+    """
+    Inserts spaces regularly in a string, every nbchars characters, after certain
+    characters (",", ";", "-", "+", "*", ")"), and keeps searching until detecting
+    one of those characters.
+
+    Args:
+        text (str): The input string.
+        nbchars (int): The number of characters after which a space should be inserted.
+
+    Returns:
+        str: The modified string with spaces inserted.
+    """
+    special_chars = (",", ";", "-", "+", "*", ")", "_")
+    new_text = ""
+    index = 0
+    while index < len(text):
+        if (
+            index + nbchars < len(text)
+            and text[index + nbchars] not in special_chars
+            and not any(c in special_chars for c in text[index : index + nbchars + 1])
+        ):
+            new_text += text[index : index + nbchars]  # Append characters
+            index += nbchars
+        else:
+            new_text += text[index : index + nbchars] + " "  # Insert space
+            index += nbchars
+    return new_text
+
+
+class WarningErrorMessageBox(QW.QDialog):
+    """Warning/Error message box
+
+    Args:
+        parent (QW.QWidget): parent widget
+        category (str): message category ("error" or "warning")
+        context (str | None): context. Defaults to None.
+        message (str | None): message. Defaults to None.
+        tip (str | None): tip. Defaults to None.
+    """
+
+    def __init__(
+        self,
+        parent: QW.QWidget,
+        category: str,
+        context: str = None,
+        message: str = None,
+        tip: str = None,
+    ) -> None:
+        super().__init__(parent)
+        assert category in ("error", "warning")
+        self.setWindowTitle(parent.window().objectName())
+
+        self.shell = PythonShellWidget(self, read_only=True)
+        self.shell.go_to_error.connect(go_to_error)
+        font = get_font(CONF, "console")
+        font.setPointSize(9)
+        self.shell.set_font(font)
+        message = traceback.format_exc() if message is None else message
+        self.shell.insert_text(message, at_end=True, error=True)
+
+        bbox = QW.QDialogButtonBox(QW.QDialogButtonBox.Ok)
+        bbox.accepted.connect(self.accept)
+        if category == "warning":
+            bbox.addButton(QW.QDialogButtonBox.Ignore).clicked.connect(self.ignore)
+
+        layout = QW.QVBoxLayout()
+
+        if category == "error":
+            width, height = 725, 400
+            icon = "MessageBoxCritical"
+            tb_title = _("Error message")
+            tb_text = _("The following traceback may help to understand the problem:")
+        else:
+            width, height = 725, 200
+            icon = "MessageBoxWarning"
+            tb_title = _("Warning message")
+            tb_text = _("Please take into account the following warning message:")
+
+        if context is not None:
+            context = insert_spaces(context, 80)
+            msgprefix = _("An error has occured during the following context:")
+            text = "<br>".join([msgprefix, f"<b>{context}</b>"])
+            ct_groupbox = QW.QGroupBox(_("Context"), self)
+            ct_layout = QW.QHBoxLayout()
+            ct_image_layout = QW.QVBoxLayout()
+            ct_image = QW.QLabel()
+            ct_image.setPixmap(get_std_icon(icon).pixmap(24, 24))
+            ct_image.setSizePolicy(QW.QSizePolicy.Fixed, QW.QSizePolicy.Fixed)
+            ct_image_layout.addWidget(ct_image)
+            ct_image_layout.addStretch()
+            ct_layout.addLayout(ct_image_layout)
+            ct_label = QW.QLabel(text)
+            ct_label.setWordWrap(True)
+            ct_label.setAlignment(QC.Qt.AlignLeft | QC.Qt.AlignTop)
+            ct_layout.addWidget(ct_label)
+            ct_groupbox.setLayout(ct_layout)
+            ct_groupbox.setSizePolicy(
+                QW.QSizePolicy.MinimumExpanding, QW.QSizePolicy.Fixed
+            )
+            layout.addWidget(ct_groupbox)
+
+        tb_groupbox = QW.QGroupBox(tb_title, self)
+        tb_layout = QW.QVBoxLayout()
+        tb_layout.addWidget(QW.QLabel(tb_text))
+        tb_layout.addWidget(self.shell)
+        tb_groupbox.setLayout(tb_layout)
+        layout.addWidget(tb_groupbox)
+
+        if tip is not None:
+            tip_groupbox = QW.QGroupBox(_("Tip"), self)
+            tip_layout = QW.QHBoxLayout()
+            tip_image_layout = QW.QVBoxLayout()
+            tip_image = QW.QLabel()
+            tip_image.setPixmap(get_std_icon("MessageBoxInformation").pixmap(24, 24))
+            tip_image.setSizePolicy(QW.QSizePolicy.Fixed, QW.QSizePolicy.Fixed)
+            tip_image_layout.addWidget(tip_image)
+            tip_image_layout.addStretch()
+            tip_layout.addLayout(tip_image_layout)
+            tip_label = QW.QLabel(tip)
+            tip_label.setWordWrap(True)
+            tip_label.setAlignment(QC.Qt.AlignLeft | QC.Qt.AlignTop)
+            tip_layout.addWidget(tip_label)
+            tip_groupbox.setLayout(tip_layout)
+            tip_groupbox.setSizePolicy(
+                QW.QSizePolicy.MinimumExpanding, QW.QSizePolicy.Fixed
+            )
+            layout.addWidget(tip_groupbox)
+
+        layout.addSpacing(10)
+        if category == "warning":
+            layout.addWidget(
+                QW.QLabel(
+                    _(
+                        "Please click on the 'Ignore' button to "
+                        "ignore this warning next time."
+                    )
+                )
+            )
+            layout.addSpacing(10)
+
+        layout.addWidget(bbox)
+
+        self.setLayout(layout)
+        self.resize(width, height)
+
+        bbox.button(QW.QDialogButtonBox.Ok).setFocus()
+
+    def ignore(self):
+        """Ignore warning next time"""
+        Conf.proc.ignore_warnings.set(True)
+        self.accept()
+
+
+def show_warning_error(
+    parent: QW.QWidget,
+    category: str,
+    context: str = None,
+    message: str = None,
+    tip: str = None,
+) -> None:
+    """Show error message
+
+    Args:
+        parent (QW.QWidget): parent widget
+        category (str): message category ("error" or "warning")
+        context (str | None): context. Defaults to None.
+        message (str | None): message. Defaults to None.
+        tip (str | None): tip. Defaults to None.
+    """
+    if category == "warning" and Conf.proc.ignore_warnings.get():
+        return
+    dlg = WarningErrorMessageBox(parent, category, context, message, tip)
+    exec_dialog(dlg)

datalab/widgets/wizard.py

@@ -0,0 +1,286 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+DataLab Wizard Widget
+---------------------
+
+The DataLab Wizard is a widget that guides the user through a series of steps
+to complete a task. It is implemented as a series of pages, each of which is
+a separate widget.
+
+The `Wizard` class is the main widget that contains the pages. The `WizardPage`
+class is the base class for the pages.
+
+This module is strongly inspired from Qt's `QWizard` and `QWizardPage` classes.
+
+.. note::
+
+    The only motivation for reimplementing the wizard widget is to
+    support complete styling with `QPalette` and `QStyle` (e.g. `guidata`'s
+    dark mode is not supported on Windows).
+"""
+
+from __future__ import annotations
+
+from qtpy import QtCore as QC
+from qtpy import QtWidgets as QW
+from qtpy.compat import getopenfilename
+from qtpy.QtWidgets import QWidget
+
+from datalab.config import _
+
+
+class WizardPage(QW.QWidget):
+    """Wizard page base class
+
+    We create our own wizard page class instead of using QWizardPage because
+    the latter does not support complete styling with `QPalette` and `QStyle`
+    (e.g. `guidata`'s dark mode is not supported on Windows).
+
+    This class reimplements the `QWizardPage` features.
+
+    """
+
+    SIG_INITIALIZE_PAGE = QC.Signal()
+    SIG_VALID_STATE_CHANGED = QC.Signal()
+
+    def __init__(self, parent: QW.QWidget | None = None) -> None:
+        super().__init__(parent)
+        self.__is_valid: bool = True
+        self.wizard: Wizard | None = None
+        self._main_layout = QW.QVBoxLayout()
+        self._user_layout = QW.QVBoxLayout()
+        self._title_label = QW.QLabel("")
+        font = self._title_label.font()
+        font.setPointSize(font.pointSize() + 4)
+        font.setBold(True)
+        self._title_label.setFont(font)
+        self._title_label.setStyleSheet("color: #1E90FF")
+        horiz_line = QW.QFrame()
+        horiz_line.setFrameShape(QW.QFrame.HLine)
+        horiz_line.setFrameShadow(QW.QFrame.Sunken)
+        self._subtitle_label = QW.QLabel("")
+        self._main_layout.addWidget(self._title_label)
+        self._main_layout.addWidget(self._subtitle_label)
+        self._main_layout.addWidget(horiz_line)
+        self._main_layout.addLayout(self._user_layout)
+        self.setLayout(self._main_layout)
+
+    def set_wizard(self, wizard: Wizard) -> None:
+        """Set the wizard"""
+        self.wizard = wizard
+
+    def get_wizard(self) -> Wizard:
+        """Return the wizard"""
+        return self.wizard
+
+    def set_title(self, title: str) -> None:
+        """Set the title of the page"""
+        self._title_label.setText(title)
+
+    def set_subtitle(self, subtitle: str) -> None:
+        """Set the subtitle of the page"""
+        self._subtitle_label.setText(subtitle)
+
+    def set_valid(self, is_valid: bool) -> None:
+        """Set the page as valid"""
+        self.__is_valid = is_valid
+        self.SIG_VALID_STATE_CHANGED.emit()
+
+    def is_valid(self) -> bool:
+        """Return whether the page is valid"""
+        return self.__is_valid
+
+    def add_to_layout(self, layout: QW.QLayout | QW.QWidget) -> None:
+        """Add a layout to the user layout"""
+        if isinstance(layout, QW.QWidget):
+            self._user_layout.addWidget(layout)
+        else:
+            self._user_layout.addLayout(layout)
+
+    def add_stretch(self) -> None:
+        """Add a stretch to the user layout"""
+        self._user_layout.addStretch()
+
+    def initialize_page(self) -> None:
+        """Initialize the page"""
+        self.SIG_INITIALIZE_PAGE.emit()
+
+    def validate_page(self) -> bool:
+        """Validate the page"""
+        return self.is_valid()
+
+
+class Wizard(QW.QDialog):
+    """Wizard base class"""
+
+    def __init__(self, parent: QWidget | None = None) -> None:
+        super().__init__(parent)
+
+        _main_layout = QW.QVBoxLayout()
+        self.setLayout(_main_layout)
+
+        self._pages_widget = QW.QStackedWidget()
+        _main_layout.addWidget(self._pages_widget)
+
+        btn_layout = QW.QHBoxLayout()
+        self._back_btn = QW.QPushButton(_("Back"))
+        self._back_btn.clicked.connect(self.go_to_previous_page)
+        self._next_btn = QW.QPushButton(_("Next"))
+        self._next_btn.clicked.connect(self.go_to_next_page)
+        self._finish_btn = QW.QPushButton(_("Finish"))
+        self._finish_btn.clicked.connect(self.accept)
+        self._cancel_btn = QW.QPushButton(_("Cancel"))
+        self._cancel_btn.clicked.connect(self.reject)
+        btn_layout.addWidget(self._back_btn)
+        btn_layout.addWidget(self._next_btn)
+        btn_layout.addWidget(self._finish_btn)
+        btn_layout.addWidget(self._cancel_btn)
+        _main_layout.addLayout(btn_layout)
+
+        self.setSizePolicy(
+            QW.QSizePolicy(QW.QSizePolicy.Minimum, QW.QSizePolicy.Minimum)
+        )
+
+    def add_page(self, page: WizardPage, last_page: bool = False) -> None:
+        """Add a page to the wizard"""
+        page.set_wizard(self)
+        page.SIG_INITIALIZE_PAGE.connect(self.__update_button_states)
+        page.SIG_VALID_STATE_CHANGED.connect(self.__update_button_states)
+        self._pages_widget.addWidget(page)
+        if last_page:
+            self._pages_widget.widget(0).initialize_page()
+
+    def __update_button_states(self, index: int | None = None) -> None:
+        """Update button states"""
+        if index is None:
+            index = self._pages_widget.currentIndex()
+        self._back_btn.setEnabled(index > 0)
+        not_last_page = index < self._pages_widget.count() - 1
+        page_valid = self._pages_widget.currentWidget().is_valid()
+        self._next_btn.setEnabled(not_last_page and page_valid)
+        is_last_page = index == self._pages_widget.count() - 1
+        self._finish_btn.setEnabled(is_last_page and page_valid)
+
+    def go_to_previous_page(self) -> None:
+        """Go to the previous page"""
+        self._pages_widget.setCurrentIndex(self._pages_widget.currentIndex() - 1)
+        self.__update_button_states()
+
+    def go_to_next_page(self) -> None:
+        """Go to the next page"""
+        if self.validate_page():
+            self._pages_widget.setCurrentIndex(self._pages_widget.currentIndex() + 1)
+            self.initialize_page()
+
+    def initialize_page(self) -> None:
+        """Initialize the page"""
+        self._pages_widget.currentWidget().initialize_page()
+
+    def validate_page(self) -> bool:
+        """Validate the page"""
+        return self._pages_widget.currentWidget().validate_page()
+
+    def accept(self) -> None:
+        """Accept the wizard"""
+        if self.validate_page():
+            super().accept()
+
+
+class ExamplePage1(WizardPage):
+    """Example wizard page 1"""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.set_title(_("Welcome to the Example Wizard"))
+        self.set_subtitle(
+            _("This wizard will guide you through the process of importing data.")
+        )
+
+    def initialize_page(self) -> None:
+        """Initialize the page"""
+        print("ExamplePage1 initialized")
+        super().initialize_page()
+
+    def validate_page(self) -> bool:
+        """Validate the page"""
+        print("ExamplePage1 validated")
+        return super().validate_page()
+
+
+class ExamplePage2(WizardPage):
+    """Example wizard page 2"""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.set_title(_("Select the Source of the Data"))
+        self.set_subtitle(
+            _("Select the source of the data to be imported (clipboard or file).")
+        )
+        self._clipboard_rb = QW.QRadioButton(_("Clipboard"))
+        self._file_rb = QW.QRadioButton(_("File"))
+        self._file_rb.toggled.connect(self.file_rb_toggled)
+        self._file_le = QW.QLineEdit()
+        self._file_btn = QW.QPushButton(_("Browse..."))
+        self._file_btn.clicked.connect(self.browse_file)
+        self.add_to_layout(self._clipboard_rb)
+        self.add_to_layout(self._file_rb)
+        self.add_to_layout(self._file_le)
+        self.add_to_layout(self._file_btn)
+
+    def initialize_page(self) -> None:
+        """Initialize the page"""
+        print("ExamplePage2 initialized")
+        super().initialize_page()
+
+    def file_rb_toggled(self, checked: bool) -> None:
+        """File radio button toggled"""
+        self._file_le.setEnabled(checked)
+        self._file_btn.setEnabled(checked)
+
+    def browse_file(self) -> None:
+        """Browse file"""
+        file_name, _filt = getopenfilename(
+            self,
+            _("Select the File to Import"),
+            "",
+            _("CSV Files (*.csv);;Text Files (*.txt);;All Files (*)"),
+        )
+        if file_name:
+            self._file_le.setText(file_name)
+
+    def validate_page(self) -> bool:
+        """Validate the page"""
+        if self._file_rb.isChecked() and not self._file_le.text():
+            QW.QMessageBox.critical(
+                self,
+                _("Error"),
+                _("Please select the file to import."),
+                QW.QMessageBox.Ok,
+            )
+            return False
+        return True
+
+
+class ExampleWizard(Wizard):
+    """Example wizard widget"""
+
+    def __init__(self) -> None:
+        super().__init__()
+        self.setWindowTitle(_("Example Wizard"))
+        self.add_page(ExamplePage1())
+        self.add_page(ExamplePage2(), last_page=True)
+
+
+def test_example_wizard():
+    """Test the import wizard"""
+    # pylint: disable=import-outside-toplevel
+    from guidata.qthelpers import qt_app_context
+
+    with qt_app_context():
+        wizard = ExampleWizard()
+        wizard.exec()
+
+
+if __name__ == "__main__":
+    test_example_wizard()

datalab_platform-1.0.1.dist-info/METADATA

@@ -0,0 +1,121 @@
+Metadata-Version: 2.4
+Name: datalab-platform
+Version: 1.0.1
+Summary: DataLab is a data processing and analysis software for scientific and industrial applications
+Author-email: Pierre Raybaut <p.raybaut@codra.fr>
+Maintainer-email: DataLab Platform Developers <p.raybaut@codra.fr>
+License-Expression: BSD-3-Clause
+Project-URL: Homepage, https://datalab-platform.com/
+Project-URL: Documentation, https://datalab-platform.com/
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows :: Windows 7
+Classifier: Operating System :: Microsoft :: Windows :: Windows 8
+Classifier: Operating System :: Microsoft :: Windows :: Windows 10
+Classifier: Operating System :: Microsoft :: Windows :: Windows 11
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Classifier: Topic :: Scientific/Engineering :: Human Machine Interfaces
+Classifier: Topic :: Scientific/Engineering :: Visualization
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Software Development :: Widget Sets
+Requires-Python: <4,>=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: guidata>=3.13.3
+Requires-Dist: PlotPy>=2.8.2
+Requires-Dist: Sigima>=1.0.2
+Requires-Dist: NumPy>=1.22
+Requires-Dist: SciPy>=1.10.1
+Requires-Dist: scikit-image>=0.19.2
+Requires-Dist: pandas>=1.4
+Requires-Dist: PyWavelets>=1.2
+Requires-Dist: psutil>=5.8
+Requires-Dist: packaging>=21.3
+Provides-Extra: qt
+Requires-Dist: PyQt5>=5.15.6; extra == "qt"
+Provides-Extra: opencv
+Requires-Dist: opencv-python-headless>=4.8.1.78; extra == "opencv"
+Provides-Extra: exe
+Requires-Dist: pyinstaller==6.16.0; extra == "exe"
+Requires-Dist: opencv-python-headless>=4.8.1.78; extra == "exe"
+Requires-Dist: PyQt5>=5.15.6; extra == "exe"
+Provides-Extra: dev
+Requires-Dist: build; extra == "dev"
+Requires-Dist: babel; extra == "dev"
+Requires-Dist: Coverage; extra == "dev"
+Requires-Dist: pylint; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Provides-Extra: doc
+Requires-Dist: sphinx; extra == "doc"
+Requires-Dist: sphinx_intl; extra == "doc"
+Requires-Dist: sphinx-sitemap; extra == "doc"
+Requires-Dist: myst_parser; extra == "doc"
+Requires-Dist: sphinx_design; extra == "doc"
+Requires-Dist: sphinx-copybutton; extra == "doc"
+Requires-Dist: pydata-sphinx-theme; extra == "doc"
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-xvfb; extra == "test"
+Dynamic: license-file
+
+![DataLab](https://raw.githubusercontent.com/DataLab-Platform/DataLab/main/doc/images/DataLab-banner.png)
+
+[![license](https://img.shields.io/pypi/l/datalab-platform.svg)](./LICENSE)
+[![pypi version](https://img.shields.io/pypi/v/datalab-platform.svg)](https://pypi.org/project/datalab-platform/)
+[![PyPI status](https://img.shields.io/pypi/status/datalab-platform.svg)](https://github.com/DataLab-Platform/DataLab)
+[![PyPI pyversions](https://img.shields.io/pypi/pyversions/datalab-platform.svg)](https://pypi.python.org/pypi/datalab-platform/)
+
+DataLab is an **open-source platform for scientific and technical data processing
+and visualization** with unique features designed to meet industrial requirements.
+
+See [DataLab website](https://datalab-platform.com/) for more details.
+
+> **Note:** This project (DataLab Platform) should not be confused with the [datalab-org](https://datalab-org.io/) project, which is a separate and unrelated initiative focused on materials science databases and computational tools.
+
+ℹ️ Created by [CODRA](https://codra.net/)/[Pierre Raybaut](https://github.com/PierreRaybaut) in 2023, developed and maintained by DataLab Platform Developers.
+
+![DataLab](https://raw.githubusercontent.com/DataLab-Platform/DataLab/main/doc/images/shots/i_blob_detection_flower.png)
+
+🧮 DataLab's processing power comes from the advanced algorithms of the object-oriented signal and image processing library [Sigima](https://github.com/DataLab-Platform/Sigima) 🚀 which is part of the DataLab Platform.
+
+![Sigima](https://raw.githubusercontent.com/DataLab-Platform/DataLab/main/doc/images/logos/Sigima-Power.png)
+
+ℹ️ DataLab is powered by [PlotPyStack](https://github.com/PlotPyStack) 🚀 for curve plotting and fast image visualization.
+
+![PlotPyStack](https://raw.githubusercontent.com/PlotPyStack/.github/main/data/plotpy-stack-powered.png)
+
+ℹ️ DataLab is built on Python and scientific libraries.
+
+![Python](https://raw.githubusercontent.com/DataLab-Platform/DataLab/main/doc/images/logos/Python.png) ![NumPy](https://raw.githubusercontent.com/DataLab-Platform/DataLab/main/doc/images/logos/NumPy.png) ![SciPy](https://raw.githubusercontent.com/DataLab-Platform/DataLab/main/doc/images/logos/SciPy.png) ![scikit-image](https://raw.githubusercontent.com/DataLab-Platform/DataLab/main/doc/images/logos/scikit-image.png) ![OpenCV](https://raw.githubusercontent.com/DataLab-Platform/DataLab/main/doc/images/logos/OpenCV.png) ![PlotPyStack](https://raw.githubusercontent.com/DataLab-Platform/DataLab/main/doc/images/logos/plotpystack.png) ![Sigima](https://raw.githubusercontent.com/DataLab-Platform/DataLab/main/doc/images/logos/Sigima.png)
+
+----
+
+Try DataLab online, without installing anything, using Binder:
+
+[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/DataLab-Platform/DataLab/binder-environments?urlpath=git-pull%3Frepo%3Dhttps%253A%252F%252Fgithub.com%252FDataLab-Platform%252FDataLab%26urlpath%3Ddesktop%252F%26branch%3Dbinder-environments)
+
+----
+
+✨ Add features to DataLab by writing your own [plugin](https://datalab-platform.com/en/features/advanced/plugins.html)
+(see [plugin examples](https://github.com/DataLab-Platform/DataLab/tree/main/plugins/examples))
+or macro (see [macro examples](https://github.com/DataLab-Platform/DataLab/tree/main/macros/examples))
+
+✨ DataLab may be remotely controlled from a third-party application (such as Jupyter,
+Spyder or any IDE):
+
+* Using the integrated [remote control](https://datalab-platform.com/en/features/advanced/remote.html)
+feature (this requires to install DataLab as a Python package)
+
+* Using the lightweight client integrated in [Sigima](https://github.com/DataLab-Platform/Sigima) (`pip install sigima`)