datalab-platform 1.0.3__py3-none-any.whl → 1.1.0__py3-none-any.whl

datalab/webapi/schema.py

@@ -0,0 +1,198 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause License
+# See LICENSE file for details
+
+"""
+Web API Schema Definitions
+==========================
+
+Pydantic models defining the API contract for DataLab Web API.
+
+These schemas define:
+
+- Object metadata (signals and images)
+- API request/response payloads
+- Event messages
+
+Design Principles
+-----------------
+
+1. **Minimal but complete**: Include only essential metadata for workspace operations
+2. **Type-safe**: Full type annotations for all fields
+3. **Serializable**: All models can be serialized to JSON
+4. **Extensible**: Designed for future additions without breaking changes
+"""
+
+from __future__ import annotations
+
+from enum import Enum
+from typing import Any, Optional
+
+from pydantic import BaseModel, Field
+
+
+class ObjectType(str, Enum):
+    """Type of data object in the workspace."""
+
+    SIGNAL = "signal"
+    IMAGE = "image"
+
+
+class ObjectMetadata(BaseModel):
+    """Metadata for a workspace object.
+
+    This is the core representation of an object in the API.
+    The actual data is transferred separately via the binary data plane.
+    """
+
+    name: str = Field(..., description="Unique object identifier/title")
+    type: ObjectType = Field(..., description="Object type (signal or image)")
+    shape: list[int] = Field(..., description="Array shape (e.g., [100] or [512, 512])")
+    dtype: str = Field(..., description="NumPy dtype string (e.g., 'float64')")
+
+    # Optional metadata
+    title: Optional[str] = Field(None, description="Display title")
+    xlabel: Optional[str] = Field(None, description="X-axis label")
+    ylabel: Optional[str] = Field(None, description="Y-axis label")
+    zlabel: Optional[str] = Field(None, description="Z-axis label (images only)")
+    xunit: Optional[str] = Field(None, description="X-axis unit")
+    yunit: Optional[str] = Field(None, description="Y-axis unit")
+    zunit: Optional[str] = Field(None, description="Z-axis unit (images only)")
+
+    # Extended attributes
+    attributes: dict[str, Any] = Field(
+        default_factory=dict, description="Additional key/value metadata"
+    )
+
+    model_config = {"extra": "ignore"}
+
+
+class ObjectListResponse(BaseModel):
+    """Response for listing workspace objects."""
+
+    objects: list[ObjectMetadata] = Field(..., description="List of object metadata")
+    count: int = Field(..., description="Total number of objects")
+
+
+class ObjectCreateRequest(BaseModel):
+    """Request to create a new object (metadata only, data sent separately)."""
+
+    name: str = Field(..., description="Object name/title")
+    type: ObjectType = Field(..., description="Object type")
+    overwrite: bool = Field(False, description="Replace existing object if present")
+
+    # Optional metadata to set
+    title: Optional[str] = Field(None, description="Display title")
+    xlabel: Optional[str] = Field(None, description="X-axis label")
+    ylabel: Optional[str] = Field(None, description="Y-axis label")
+    zlabel: Optional[str] = Field(None, description="Z-axis label (images only)")
+    xunit: Optional[str] = Field(None, description="X-axis unit")
+    yunit: Optional[str] = Field(None, description="Y-axis unit")
+    zunit: Optional[str] = Field(None, description="Z-axis unit (images only)")
+    attributes: dict[str, Any] = Field(
+        default_factory=dict, description="Additional metadata"
+    )
+
+
+class MetadataPatchRequest(BaseModel):
+    """Request to update object metadata."""
+
+    title: Optional[str] = Field(None, description="New display title")
+    xlabel: Optional[str] = Field(None, description="New X-axis label")
+    ylabel: Optional[str] = Field(None, description="New Y-axis label")
+    zlabel: Optional[str] = Field(None, description="New Z-axis label")
+    xunit: Optional[str] = Field(None, description="New X-axis unit")
+    yunit: Optional[str] = Field(None, description="New Y-axis unit")
+    zunit: Optional[str] = Field(None, description="New Z-axis unit")
+    attributes: Optional[dict[str, Any]] = Field(
+        None, description="Attributes to merge (not replace)"
+    )
+
+
+class ApiStatus(BaseModel):
+    """API server status information."""
+
+    running: bool = Field(..., description="Whether the API server is running")
+    version: str = Field(..., description="DataLab version")
+    api_version: str = Field("v1", description="API version")
+    url: Optional[str] = Field(None, description="Base URL when running")
+    workspace_mode: str = Field(..., description="Current workspace mode")
+    localhost_no_token: bool = Field(
+        False, description="Whether localhost connections can bypass authentication"
+    )
+
+
+class ErrorResponse(BaseModel):
+    """Standard error response."""
+
+    error: str = Field(..., description="Error type/code")
+    message: str = Field(..., description="Human-readable error message")
+    detail: Optional[str] = Field(None, description="Additional detail")
+
+
+# Event types for WebSocket (future)
+class EventType(str, Enum):
+    """Types of workspace events."""
+
+    OBJECT_ADDED = "object_added"
+    OBJECT_UPDATED = "object_updated"
+    OBJECT_REMOVED = "object_removed"
+    OBJECT_RENAMED = "object_renamed"
+    WORKSPACE_CLEARED = "workspace_cleared"
+
+
+class WorkspaceEvent(BaseModel):
+    """A workspace change event (for WebSocket notifications)."""
+
+    event: EventType = Field(..., description="Event type")
+    object_name: Optional[str] = Field(None, description="Affected object name")
+    old_name: Optional[str] = Field(None, description="Old name (for rename events)")
+    timestamp: float = Field(..., description="Unix timestamp")
+
+
+# =============================================================================
+# Computation API schemas
+# =============================================================================
+
+
+class SelectObjectsRequest(BaseModel):
+    """Request to select objects in a panel."""
+
+    selection: list[str] = Field(
+        ..., description="List of object names/titles to select"
+    )
+    panel: Optional[ObjectType] = Field(
+        None, description="Panel to select in (signal/image). None = current panel."
+    )
+
+
+class SelectObjectsResponse(BaseModel):
+    """Response for object selection."""
+
+    selected: list[str] = Field(..., description="List of selected object names")
+    panel: str = Field(..., description="Panel where selection was made")
+
+
+class CalcRequest(BaseModel):
+    """Request to call a computation function.
+
+    The computation is applied to the currently selected objects in DataLab.
+    """
+
+    name: str = Field(
+        ..., description="Computation function name (e.g., 'normalize', 'fft')"
+    )
+    param: Optional[dict[str, Any]] = Field(
+        None,
+        description="Computation parameters as a dictionary. "
+        "Keys are parameter names, values are parameter values.",
+    )
+
+
+class CalcResponse(BaseModel):
+    """Response from a computation."""
+
+    success: bool = Field(..., description="Whether computation succeeded")
+    function: str = Field(..., description="Name of the computation function called")
+    result_names: list[str] = Field(
+        default_factory=list, description="Names of newly created result objects"
+    )

datalab/webapi/serialization.py

@@ -0,0 +1,388 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause License
+# See LICENSE file for details
+
+"""
+Web API Serialization
+=====================
+
+Binary serialization of DataLab objects using NumPy's NPZ format.
+
+This module handles the data plane of the Web API, efficiently transferring
+large numerical arrays between DataLab and clients.
+
+Format Specification (V1)
+-------------------------
+
+The NPZ archive contains:
+
+For SignalObj:
+    - ``x.npy``: X coordinates (1D float64 array)
+    - ``y.npy``: Y data (1D float64 array)
+    - ``dx.npy``: X uncertainties (optional)
+    - ``dy.npy``: Y uncertainties (optional)
+    - ``metadata.json``: JSON-encoded metadata
+
+For ImageObj:
+    - ``data.npy``: Image data (2D array, preserves dtype)
+    - ``metadata.json``: JSON-encoded metadata
+
+Metadata JSON includes:
+    - ``type``: "signal" or "image"
+    - ``title``, ``xlabel``, ``ylabel``, etc.
+    - ``x0``, ``y0``, ``dx``, ``dy`` (for images)
+"""
+
+from __future__ import annotations
+
+import io
+import json
+import zipfile
+from typing import TYPE_CHECKING, Union
+
+import numpy as np
+from sigima.objects import ImageObj, SignalObj
+
+if TYPE_CHECKING:
+    DataObject = Union[SignalObj, ImageObj]
+
+
+def _to_python_scalar(value):
+    """Convert numpy scalar types to Python native types for JSON serialization.
+
+    Args:
+        value: Any value, possibly a numpy scalar.
+
+    Returns:
+        Python native type if input was a numpy scalar, otherwise unchanged.
+    """
+    if isinstance(value, np.integer):
+        return int(value)
+    if isinstance(value, np.floating):
+        return float(value)
+    if isinstance(value, np.bool_):
+        return bool(value)
+    return value
+
+
+def _make_json_serializable(value):  # pylint: disable=too-many-return-statements
+    """Recursively convert a value to be JSON serializable.
+
+    Handles numpy arrays, numpy scalars, nested dicts, and lists.
+
+    Args:
+        value: Any value that may contain numpy types.
+
+    Returns:
+        JSON-serializable value.
+    """
+    if isinstance(value, dict):
+        return {k: _make_json_serializable(v) for k, v in value.items()}
+    if isinstance(value, list):
+        return [_make_json_serializable(item) for item in value]
+    if isinstance(value, tuple):
+        return [_make_json_serializable(item) for item in value]
+    if isinstance(value, np.ndarray):
+        return value.tolist()
+    if isinstance(value, np.integer):
+        return int(value)
+    if isinstance(value, np.floating):
+        return float(value)
+    if isinstance(value, np.bool_):
+        return bool(value)
+    return value
+
+
+def _serialize_obj_metadata(obj_metadata: dict) -> dict:
+    """Convert object metadata to JSON-serializable format.
+
+    Handles numpy arrays (from GeometryResult.coords, TableResult, etc.)
+    by converting them to nested lists, and numpy scalar types (int64, float64)
+    to Python native types.
+
+    Args:
+        obj_metadata: The object's metadata dictionary.
+
+    Returns:
+        JSON-serializable dictionary.
+    """
+    return _make_json_serializable(obj_metadata)
+
+
+def _deserialize_obj_metadata(serialized: dict) -> dict:
+    """Convert deserialized metadata back to original types.
+
+    Converts nested lists back to numpy arrays where appropriate
+    (for coords fields in geometry results).
+
+    Args:
+        serialized: The JSON-deserialized metadata.
+
+    Returns:
+        Metadata with numpy arrays restored.
+    """
+    result = {}
+    for key, value in serialized.items():
+        if isinstance(value, dict):
+            # Recursively handle nested dicts
+            result[key] = _deserialize_obj_metadata(value)
+        elif isinstance(value, list) and key == "coords":
+            # Convert coords back to numpy array
+            result[key] = np.array(value)
+        else:
+            result[key] = value
+    return result
+
+
+def serialize_object_to_npz(obj: DataObject, *, compress: bool = True) -> bytes:
+    """Serialize a SignalObj or ImageObj to NPZ format.
+
+    Args:
+        obj: The object to serialize.
+        compress: If True (default), use ZIP deflate compression.
+            Set to False for faster serialization at the cost of larger size.
+            For incompressible data (random images), False can be 10-30x faster.
+
+    Returns:
+        Bytes containing the NPZ archive.
+
+    Raises:
+        TypeError: If object type is not supported.
+    """
+    buffer = io.BytesIO()
+
+    # Detect object type
+    obj_type = type(obj).__name__
+
+    if obj_type == "SignalObj":
+        _serialize_signal(obj, buffer, compress=compress)
+    elif obj_type == "ImageObj":
+        _serialize_image(obj, buffer, compress=compress)
+    else:
+        raise TypeError(f"Unsupported object type: {obj_type}")
+
+    return buffer.getvalue()
+
+
+def _serialize_signal(obj, buffer: io.BytesIO, *, compress: bool = True) -> None:
+    """Serialize a SignalObj to NPZ format."""
+    # Build metadata dict
+    metadata = {
+        "type": "signal",
+        "title": getattr(obj, "title", None),
+        "xlabel": getattr(obj, "xlabel", None),
+        "ylabel": getattr(obj, "ylabel", None),
+        "xunit": getattr(obj, "xunit", None),
+        "yunit": getattr(obj, "yunit", None),
+    }
+    # Include object metadata (contains Geometry_*, Table_* results)
+    obj_metadata = getattr(obj, "metadata", None)
+    if obj_metadata:
+        metadata["obj_metadata"] = _serialize_obj_metadata(obj_metadata)
+
+    # Create zip archive
+    compression = zipfile.ZIP_DEFLATED if compress else zipfile.ZIP_STORED
+    with zipfile.ZipFile(buffer, "w", compression) as zf:
+        # Write arrays
+        _write_array_to_zip(zf, "x.npy", obj.x)
+        _write_array_to_zip(zf, "y.npy", obj.y)
+
+        if obj.dx is not None:
+            _write_array_to_zip(zf, "dx.npy", obj.dx)
+        if obj.dy is not None:
+            _write_array_to_zip(zf, "dy.npy", obj.dy)
+
+        # Write metadata
+        zf.writestr("metadata.json", json.dumps(metadata, ensure_ascii=False))
+
+
+def _serialize_image(obj, buffer: io.BytesIO, *, compress: bool = True) -> None:
+    """Serialize an ImageObj to NPZ format."""
+    # Build metadata dict - use _to_python_scalar for numeric values that may be
+    # numpy scalars after HDF5 deserialization
+    metadata = {
+        "type": "image",
+        "title": getattr(obj, "title", None),
+        "xlabel": getattr(obj, "xlabel", None),
+        "ylabel": getattr(obj, "ylabel", None),
+        "zlabel": getattr(obj, "zlabel", None),
+        "xunit": getattr(obj, "xunit", None),
+        "yunit": getattr(obj, "yunit", None),
+        "zunit": getattr(obj, "zunit", None),
+        "x0": _to_python_scalar(getattr(obj, "x0", 0.0)),
+        "y0": _to_python_scalar(getattr(obj, "y0", 0.0)),
+        "dx": _to_python_scalar(getattr(obj, "dx", 1.0)),
+        "dy": _to_python_scalar(getattr(obj, "dy", 1.0)),
+    }
+    # Include object metadata (contains Geometry_*, Table_* results)
+    obj_metadata = getattr(obj, "metadata", None)
+    if obj_metadata:
+        metadata["obj_metadata"] = _serialize_obj_metadata(obj_metadata)
+
+    # Create zip archive
+    compression = zipfile.ZIP_DEFLATED if compress else zipfile.ZIP_STORED
+    with zipfile.ZipFile(buffer, "w", compression) as zf:
+        _write_array_to_zip(zf, "data.npy", obj.data)
+        zf.writestr("metadata.json", json.dumps(metadata, ensure_ascii=False))
+
+
+def _write_array_to_zip(zf: zipfile.ZipFile, name: str, arr: np.ndarray) -> None:
+    """Write a numpy array to a zip file."""
+    arr_buffer = io.BytesIO()
+    np.save(arr_buffer, arr, allow_pickle=False)
+    zf.writestr(name, arr_buffer.getvalue())
+
+
+def deserialize_object_from_npz(data: bytes) -> DataObject:
+    """Deserialize a SignalObj or ImageObj from NPZ format.
+
+    Args:
+        data: Bytes containing the NPZ archive.
+
+    Returns:
+        SignalObj or ImageObj.
+
+    Raises:
+        ValueError: If the archive format is invalid.
+    """
+    buffer = io.BytesIO(data)
+
+    with zipfile.ZipFile(buffer, "r") as zf:
+        # Read metadata
+        if "metadata.json" not in zf.namelist():
+            raise ValueError("Invalid NPZ format: missing metadata.json")
+
+        metadata = json.loads(zf.read("metadata.json"))
+        obj_type = metadata.get("type")
+
+        if obj_type == "signal":
+            return _deserialize_signal(zf, metadata)
+        if obj_type == "image":
+            return _deserialize_image(zf, metadata)
+
+        raise ValueError(f"Unknown object type in NPZ: {obj_type}")
+
+
+def _read_array_from_zip(zf: zipfile.ZipFile, name: str) -> np.ndarray | None:
+    """Read a numpy array from a zip file."""
+    if name not in zf.namelist():
+        return None
+    arr_buffer = io.BytesIO(zf.read(name))
+    return np.load(arr_buffer, allow_pickle=False)
+
+
+def _deserialize_signal(zf: zipfile.ZipFile, metadata: dict) -> DataObject:
+    """Deserialize a SignalObj from NPZ archive."""
+    x = _read_array_from_zip(zf, "x.npy")
+    y = _read_array_from_zip(zf, "y.npy")
+    dx = _read_array_from_zip(zf, "dx.npy")
+    dy = _read_array_from_zip(zf, "dy.npy")
+
+    if x is None or y is None:
+        raise ValueError("Invalid signal NPZ: missing x.npy or y.npy")
+
+    obj = SignalObj()
+    obj.set_xydata(x, y, dx=dx, dy=dy)
+
+    # Set metadata
+    if metadata.get("title"):
+        obj.title = metadata["title"]
+    if metadata.get("xlabel"):
+        obj.xlabel = metadata["xlabel"]
+    if metadata.get("ylabel"):
+        obj.ylabel = metadata["ylabel"]
+    if metadata.get("xunit"):
+        obj.xunit = metadata["xunit"]
+    if metadata.get("yunit"):
+        obj.yunit = metadata["yunit"]
+
+    # Restore object metadata (Geometry_*, Table_* results)
+    if metadata.get("obj_metadata"):
+        obj.metadata = _deserialize_obj_metadata(metadata["obj_metadata"])
+
+    return obj
+
+
+def _deserialize_image(zf: zipfile.ZipFile, metadata: dict) -> DataObject:
+    """Deserialize an ImageObj from NPZ archive."""
+    data = _read_array_from_zip(zf, "data.npy")
+    if data is None:
+        raise ValueError("Invalid image NPZ: missing data.npy")
+
+    obj = ImageObj()
+    obj.data = data
+
+    # Set metadata
+    if metadata.get("title"):
+        obj.title = metadata["title"]
+    if metadata.get("xlabel"):
+        obj.xlabel = metadata["xlabel"]
+    if metadata.get("ylabel"):
+        obj.ylabel = metadata["ylabel"]
+    if metadata.get("zlabel"):
+        obj.zlabel = metadata["zlabel"]
+    if metadata.get("xunit"):
+        obj.xunit = metadata["xunit"]
+    if metadata.get("yunit"):
+        obj.yunit = metadata["yunit"]
+    if metadata.get("zunit"):
+        obj.zunit = metadata["zunit"]
+
+    # Set coordinate info
+    obj.x0 = metadata.get("x0", 0.0)
+    obj.y0 = metadata.get("y0", 0.0)
+    obj.dx = metadata.get("dx", 1.0)
+    obj.dy = metadata.get("dy", 1.0)
+
+    # Restore object metadata (Geometry_*, Table_* results)
+    if metadata.get("obj_metadata"):
+        obj.metadata = _deserialize_obj_metadata(metadata["obj_metadata"])
+
+    return obj
+
+
+def object_to_metadata(obj: DataObject, name: str) -> dict:
+    """Extract metadata from an object for API responses.
+
+    Args:
+        obj: The object to extract metadata from.
+        name: The object name in the workspace.
+
+    Returns:
+        Dictionary suitable for ObjectMetadata schema.
+    """
+    obj_type = type(obj).__name__
+
+    if obj_type == "SignalObj":
+        return {
+            "name": name,
+            "type": "signal",
+            "shape": list(obj.y.shape),
+            "dtype": str(obj.y.dtype),
+            "title": getattr(obj, "title", None),
+            "xlabel": getattr(obj, "xlabel", None),
+            "ylabel": getattr(obj, "ylabel", None),
+            "xunit": getattr(obj, "xunit", None),
+            "yunit": getattr(obj, "yunit", None),
+            "attributes": {},
+        }
+    if obj_type == "ImageObj":
+        return {
+            "name": name,
+            "type": "image",
+            "shape": list(obj.data.shape),
+            "dtype": str(obj.data.dtype),
+            "title": getattr(obj, "title", None),
+            "xlabel": getattr(obj, "xlabel", None),
+            "ylabel": getattr(obj, "ylabel", None),
+            "zlabel": getattr(obj, "zlabel", None),
+            "xunit": getattr(obj, "xunit", None),
+            "yunit": getattr(obj, "yunit", None),
+            "zunit": getattr(obj, "zunit", None),
+            "attributes": {
+                "x0": _to_python_scalar(getattr(obj, "x0", 0.0)),
+                "y0": _to_python_scalar(getattr(obj, "y0", 0.0)),
+                "dx": _to_python_scalar(getattr(obj, "dx", 1.0)),
+                "dy": _to_python_scalar(getattr(obj, "dy", 1.0)),
+            },
+        }
+    raise TypeError(f"Unsupported object type: {obj_type}")

datalab/widgets/status.py

@@ -247,3 +247,64 @@ class XMLRPCStatus(BaseStatus):
         else:
             self.label.setText(text + str(self.port))
             self.set_icon("libre-gui-link.svg")
+
+
+class WebAPIStatus(BaseStatus):
+    """Web API status widget.
+    Shows the Web API server status and port number.
+
+    Args:
+        parent (QWidget): parent widget
+    """
+
+    SIG_SHOW_INFO = QC.Signal()  # Signal to show connection info
+    SIG_START_SERVER = QC.Signal()  # Signal to propose starting server
+
+    def __init__(self, parent: QW.QWidget | None = None) -> None:
+        super().__init__(None, parent)
+        self.port: int | None = None
+        self.url: str | None = None
+        self.label.setCursor(QG.QCursor(QC.Qt.PointingHandCursor))
+        self.label.mouseReleaseEvent = self.on_click
+        self.update_status()  # Initialize widget state
+
+    def on_click(self, event: QG.QMouseEvent) -> None:
+        """Handle mouse click event on label.
+
+        Args:
+            event: mouse event
+        """
+        if event.button() == QC.Qt.LeftButton:
+            if self.port is None:
+                self.SIG_START_SERVER.emit()
+            else:
+                self.SIG_SHOW_INFO.emit()
+
+    def set_status(self, url: str | None, port: int | None) -> None:
+        """Set Web API server status.
+
+        Args:
+            url: Web API server URL (e.g. "http://127.0.0.1:8080").
+                If None, Web API server is not running.
+            port: Web API server port number.
+        """
+        self.url = url
+        self.port = port
+        self.update_status()
+
+    def update_status(self) -> None:
+        """Update status widget"""
+        if self.port is None:
+            self.label.setText(_("Web API"))
+            self.set_icon("libre-gui-unlink.svg")
+            self.setToolTip(
+                _("Web API server is not running") + "\n" + _("Click to start")
+            )
+        else:
+            self.label.setText(_("Web API:") + " " + str(self.port))
+            self.set_icon("libre-gui-link.svg")
+            tooltip = _("Web API server is running") + "\n"
+            if self.url:
+                tooltip += f"URL: {self.url}\n"
+            tooltip += _("Click to view connection info")
+            self.setToolTip(tooltip)

{datalab_platform-1.0.3.dist-info → datalab_platform-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: datalab-platform
-Version: 1.0.3
+Version: 1.1.0
 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>
@@ -34,14 +34,17 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: guidata>=3.13.4
 Requires-Dist: PlotPy>=2.8.2
-Requires-Dist: Sigima>=1.0.4
-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: Sigima>=1.1.0
+Requires-Dist: NumPy<2.5,>=1.22
+Requires-Dist: SciPy<1.17,>=1.10.1
+Requires-Dist: scikit-image<0.27,>=0.19.2
+Requires-Dist: pandas<3.0,>=1.4
+Requires-Dist: PyWavelets<2.0,>=1.2
 Requires-Dist: psutil>=5.8
 Requires-Dist: packaging>=21.3
+Requires-Dist: fastapi>=0.110.0
+Requires-Dist: uvicorn[standard]>=0.27.0
+Requires-Dist: pydantic>=2.0
 Provides-Extra: qt
 Requires-Dist: PyQt5>=5.15.6; extra == "qt"
 Provides-Extra: opencv
@@ -68,6 +71,7 @@ Requires-Dist: pydata-sphinx-theme; extra == "doc"
 Provides-Extra: test
 Requires-Dist: pytest; extra == "test"
 Requires-Dist: pytest-xvfb; extra == "test"
+Requires-Dist: httpx; extra == "test"
 Dynamic: license-file
 
 ![DataLab](https://raw.githubusercontent.com/DataLab-Platform/DataLab/main/doc/images/DataLab-banner.png)